struct _IO_FILE;
struct _IO_FILE *_coverage_fout  ;
extern char ___coverage_array[6759] ;
typedef unsigned int size_t;
typedef long wchar_t;
struct __anonstruct___wait_terminated_1 {
   unsigned int __w_termsig : 7 ;
   unsigned int __w_coredump : 1 ;
   unsigned int __w_retcode : 8 ;
   unsigned int  : 16 ;
};
struct __anonstruct___wait_stopped_2 {
   unsigned int __w_stopval : 8 ;
   unsigned int __w_stopsig : 8 ;
   unsigned int  : 16 ;
};
union wait {
   int w_status ;
   struct __anonstruct___wait_terminated_1 __wait_terminated ;
   struct __anonstruct___wait_stopped_2 __wait_stopped ;
};
union __anonunion___WAIT_STATUS_3 {
   union wait *__uptr ;
   int *__iptr ;
};
typedef union __anonunion___WAIT_STATUS_3  __attribute__((__transparent_union__)) __WAIT_STATUS;
struct __anonstruct_div_t_4 {
   int quot ;
   int rem ;
};
typedef struct __anonstruct_div_t_4 div_t;
struct __anonstruct_ldiv_t_5 {
   long quot ;
   long rem ;
};
typedef struct __anonstruct_ldiv_t_5 ldiv_t;
struct __anonstruct_lldiv_t_6 {
   long long quot ;
   long long rem ;
};
typedef struct __anonstruct_lldiv_t_6 lldiv_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] ;
};
typedef struct __locale_struct *__locale_t;
typedef __locale_t locale_t;
typedef unsigned char __u_char;
typedef unsigned short __u_short;
typedef unsigned int __u_int;
typedef unsigned long __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;
typedef long long __quad_t;
typedef unsigned long long __u_quad_t;
typedef __u_quad_t __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long __ino_t;
typedef __u_quad_t __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned int __nlink_t;
typedef long __off_t;
typedef __quad_t __off64_t;
typedef int __pid_t;
struct __anonstruct___fsid_t_7 {
   int __val[2] ;
};
typedef struct __anonstruct___fsid_t_7 __fsid_t;
typedef long __clock_t;
typedef unsigned long __rlim_t;
typedef __u_quad_t __rlim64_t;
typedef unsigned int __id_t;
typedef long __time_t;
typedef unsigned int __useconds_t;
typedef long __suseconds_t;
typedef int __daddr_t;
typedef long __swblk_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void *__timer_t;
typedef long __blksize_t;
typedef long __blkcnt_t;
typedef __quad_t __blkcnt64_t;
typedef unsigned long __fsblkcnt_t;
typedef __u_quad_t __fsblkcnt64_t;
typedef unsigned long __fsfilcnt_t;
typedef __u_quad_t __fsfilcnt64_t;
typedef int __ssize_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef int __intptr_t;
typedef unsigned int __socklen_t;
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
typedef __ino64_t ino64_t;
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __pid_t pid_t;
typedef __id_t id_t;
typedef __ssize_t ssize_t;
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
typedef __clock_t clock_t;
typedef __time_t time_t;
typedef __clockid_t clockid_t;
typedef __timer_t timer_t;
typedef __useconds_t useconds_t;
typedef __suseconds_t suseconds_t;
typedef unsigned long ulong;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef signed char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int u_int32_t;
typedef unsigned long long u_int64_t;
typedef int register_t;
typedef int __sig_atomic_t;
struct __anonstruct___sigset_t_8 {
   unsigned long __val[1024U / (8U * sizeof(unsigned long ))] ;
};
typedef struct __anonstruct___sigset_t_8 __sigset_t;
typedef __sigset_t sigset_t;
struct timespec {
   __time_t tv_sec ;
   long tv_nsec ;
};
struct timeval {
   __time_t tv_sec ;
   __suseconds_t tv_usec ;
};
typedef long __fd_mask;
struct __anonstruct_fd_set_9 {
   __fd_mask fds_bits[1024 / (8 * (int )sizeof(__fd_mask ))] ;
};
typedef struct __anonstruct_fd_set_9 fd_set;
typedef __fd_mask fd_mask;
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
typedef unsigned long pthread_t;
union __anonunion_pthread_attr_t_10 {
   char __size[36] ;
   long __align ;
};
typedef union __anonunion_pthread_attr_t_10 pthread_attr_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 ;
};
typedef union __anonunion_pthread_mutex_t_11 pthread_mutex_t;
union __anonunion_pthread_mutexattr_t_13 {
   char __size[4] ;
   long __align ;
};
typedef union __anonunion_pthread_mutexattr_t_13 pthread_mutexattr_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 ;
};
typedef union __anonunion_pthread_cond_t_14 pthread_cond_t;
union __anonunion_pthread_condattr_t_16 {
   char __size[4] ;
   long __align ;
};
typedef union __anonunion_pthread_condattr_t_16 pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_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 ;
};
typedef union __anonunion_pthread_rwlock_t_17 pthread_rwlock_t;
union __anonunion_pthread_rwlockattr_t_19 {
   char __size[8] ;
   long __align ;
};
typedef union __anonunion_pthread_rwlockattr_t_19 pthread_rwlockattr_t;
typedef int volatile   pthread_spinlock_t;
union __anonunion_pthread_barrier_t_20 {
   char __size[20] ;
   long __align ;
};
typedef union __anonunion_pthread_barrier_t_20 pthread_barrier_t;
union __anonunion_pthread_barrierattr_t_21 {
   char __size[4] ;
   int __align ;
};
typedef union __anonunion_pthread_barrierattr_t_21 pthread_barrierattr_t;
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 ;
};
struct drand48_data {
   unsigned short __x[3] ;
   unsigned short __old_x[3] ;
   unsigned short __c ;
   unsigned short __init ;
   unsigned long long __a ;
};
typedef int (*__compar_fn_t)(void const   * , void const   * );
typedef int (*comparison_fn_t)(void const   * , void const   * );
typedef int (*__compar_d_fn_t)(void const   * , void const   * , void * );
typedef long double float_t;
typedef long double double_t;
enum __anonenum_22 {
    FP_NAN = 0,
    FP_INFINITE = 1,
    FP_ZERO = 2,
    FP_SUBNORMAL = 3,
    FP_NORMAL = 4
} ;
enum __anonenum__LIB_VERSION_TYPE_23 {
    _IEEE_ = -1,
    _SVID_ = 0,
    _XOPEN_ = 1,
    _POSIX_ = 2,
    _ISOC_ = 3
} ;
typedef enum __anonenum__LIB_VERSION_TYPE_23 _LIB_VERSION_TYPE;
struct exception {
   int type ;
   char *name ;
   double arg1 ;
   double arg2 ;
   double retval ;
};
union __anonunion___u_24 {
   float __f ;
   int __i ;
};
union __anonunion___u_25 {
   double __d ;
   int __i[2] ;
};
union __anonunion___u_26 {
   long double __l ;
   int __i[3] ;
};
union __anonunion___n_27 {
   long double __xld ;
   unsigned int __xi[3] ;
};
union __anonunion_28 {
   double __d ;
   int __i[2] ;
};
typedef struct _IO_FILE FILE;
typedef struct _IO_FILE __FILE;
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_fpos_t_31 {
   __off_t __pos ;
   __mbstate_t __state ;
};
typedef struct __anonstruct__G_fpos_t_31 _G_fpos_t;
struct __anonstruct__G_fpos64_t_32 {
   __off64_t __pos ;
   __mbstate_t __state ;
};
typedef struct __anonstruct__G_fpos64_t_32 _G_fpos64_t;
typedef short _G_int16_t;
typedef int _G_int32_t;
typedef unsigned short _G_uint16_t;
typedef unsigned int _G_uint32_t;
typedef __builtin_va_list __gnuc_va_list;
struct _IO_jump_t;
typedef void _IO_lock_t;
struct _IO_marker {
   struct _IO_marker *_next ;
   struct _IO_FILE *_sbuf ;
   int _pos ;
};
enum __codecvt_result {
    __codecvt_ok = 0,
    __codecvt_partial = 1,
    __codecvt_error = 2,
    __codecvt_noconv = 3
} ;
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 )] ;
};
typedef struct _IO_FILE _IO_FILE;
struct _IO_FILE_plus;
typedef __ssize_t __io_read_fn(void *__cookie , char *__buf , size_t __nbytes );
typedef __ssize_t __io_write_fn(void *__cookie , char const   *__buf ,
                                size_t __n );
typedef int __io_seek_fn(void *__cookie , __off64_t *__pos , int __w );
typedef int __io_close_fn(void *__cookie );
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
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 struct __anonstruct__IO_cookie_io_functions_t_33 _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
typedef __gnuc_va_list va_list;
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
struct obstack;
typedef long Lmid_t;
struct __anonstruct_Dl_info_34 {
   char const   *dli_fname ;
   void *dli_fbase ;
   char const   *dli_sname ;
   void *dli_saddr ;
};
typedef struct __anonstruct_Dl_info_34 Dl_info;
enum __anonenum_35 {
    RTLD_DL_SYMENT = 1,
    RTLD_DL_LINKMAP = 2
} ;
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
} ;
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] ;
};
typedef struct __anonstruct_Dl_serinfo_38 Dl_serinfo;
typedef long tsrm_intptr_t;
typedef unsigned long tsrm_uintptr_t;
struct _zend_leak_info {
   void *addr ;
   size_t size ;
   char const   *filename ;
   uint lineno ;
   char const   *orig_filename ;
   uint orig_lineno ;
};
typedef struct _zend_leak_info zend_leak_info;
struct _zend_mm_heap;
typedef struct _zend_mm_heap zend_mm_heap;
struct _zend_mm_storage;
typedef struct _zend_mm_storage zend_mm_storage;
struct _zend_mm_segment {
   size_t size ;
   struct _zend_mm_segment *next_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 ) ;
};
typedef struct _zend_mm_mem_handlers zend_mm_mem_handlers;
struct _zend_mm_storage {
   zend_mm_mem_handlers const   *handlers ;
   void *data ;
};
typedef unsigned char zend_bool;
typedef unsigned char zend_uchar;
typedef unsigned int zend_uint;
typedef unsigned long zend_ulong;
typedef unsigned short zend_ushort;
typedef long long zend_long64;
typedef unsigned long long zend_ulong64;
typedef long zend_intptr_t;
typedef unsigned long zend_uintptr_t;
typedef unsigned int zend_object_handle;
struct _zend_object_handlers;
typedef struct _zend_object_handlers zend_object_handlers;
struct _zend_object_value {
   zend_object_handle handle ;
   zend_object_handlers const   *handlers ;
};
typedef struct _zend_object_value zend_object_value;
typedef ulong (*hash_func_t)(char const   *arKey , uint nKeyLength );
typedef int (*compare_func_t)(void const   * , void const   * );
typedef void (*sort_func_t)(void * , size_t  , size_t  ,
                            int (*)(void const   * , void const   * ) );
typedef void (*dtor_func_t)(void *pDest );
typedef void (*copy_ctor_func_t)(void *pElement );
typedef void (*copy_ctor_param_func_t)(void *pElement , void *pParam );
struct _hashtable;
struct bucket {
   ulong h ;
   uint nKeyLength ;
   void *pData ;
   void *pDataPtr ;
   struct bucket *pListNext ;
   struct bucket *pListLast ;
   struct bucket *pNext ;
   struct bucket *pLast ;
   char const   *arKey ;
};
typedef struct bucket Bucket;
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 ;
};
typedef struct _hashtable HashTable;
struct _zend_hash_key {
   char const   *arKey ;
   uint nKeyLength ;
   ulong h ;
};
typedef struct _zend_hash_key zend_hash_key;
typedef zend_bool (*merge_checker_func_t)(HashTable *target_ht ,
                                          void *source_data ,
                                          zend_hash_key *hash_key ,
                                          void *pParam );
typedef Bucket *HashPosition;
typedef int (*apply_func_t)(void *pDest );
typedef int (*apply_func_arg_t)(void *pDest , void *argument );
typedef int (*apply_func_args_t)(void *pDest , int num_args , va_list args ,
                                 zend_hash_key *hash_key );
struct _HashPointer {
   HashPosition pos ;
   ulong h ;
};
typedef struct _HashPointer HashPointer;
struct _zend_ts_hashtable {
   HashTable hash ;
   zend_uint reader ;
};
typedef struct _zend_ts_hashtable TsHashTable;
struct _zend_llist_element {
   struct _zend_llist_element *next ;
   struct _zend_llist_element *prev ;
   char data[1] ;
};
typedef struct _zend_llist_element zend_llist_element;
typedef void (*llist_dtor_func_t)(void * );
typedef int (*llist_compare_func_t)(zend_llist_element const   ** ,
                                    zend_llist_element const   ** );
typedef void (*llist_apply_with_args_func_t)(void *data , int num_args ,
                                             va_list args );
typedef void (*llist_apply_with_arg_func_t)(void *data , void *arg );
typedef void (*llist_apply_func_t)(void * );
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 ;
};
typedef struct _zend_llist zend_llist;
typedef zend_llist_element *zend_llist_position;
struct _zval_struct;
typedef struct _zval_struct zval;
struct _zend_class_entry;
typedef struct _zend_class_entry zend_class_entry;
struct _zend_guard {
   zend_bool in_get ;
   zend_bool in_set ;
   zend_bool in_unset ;
   zend_bool in_isset ;
   zend_bool dummy ;
};
typedef struct _zend_guard zend_guard;
struct _zend_object {
   zend_class_entry *ce ;
   HashTable *properties ;
   zval **properties_table ;
   HashTable *guards ;
};
typedef struct _zend_object zend_object;
union _zend_function;
struct _zend_property_info;
struct _zend_literal;
typedef zval *(*zend_object_read_property_t)(zval *object , zval *member ,
                                             int type ,
                                             struct _zend_literal  const  *key );
typedef zval *(*zend_object_read_dimension_t)(zval *object , zval *offset ,
                                              int type );
typedef void (*zend_object_write_property_t)(zval *object , zval *member ,
                                             zval *value ,
                                             struct _zend_literal  const  *key );
typedef void (*zend_object_write_dimension_t)(zval *object , zval *offset ,
                                              zval *value );
typedef zval **(*zend_object_get_property_ptr_ptr_t)(zval *object ,
                                                     zval *member ,
                                                     struct _zend_literal  const  *key );
typedef void (*zend_object_set_t)(zval **object , zval *value );
typedef zval *(*zend_object_get_t)(zval *object );
typedef int (*zend_object_has_property_t)(zval *object , zval *member ,
                                          int has_set_exists ,
                                          struct _zend_literal  const  *key );
typedef int (*zend_object_has_dimension_t)(zval *object , zval *member ,
                                           int check_empty );
typedef void (*zend_object_unset_property_t)(zval *object , zval *member ,
                                             struct _zend_literal  const  *key );
typedef void (*zend_object_unset_dimension_t)(zval *object , zval *offset );
typedef HashTable *(*zend_object_get_properties_t)(zval *object );
typedef HashTable *(*zend_object_get_debug_info_t)(zval *object , int *is_temp );
typedef int (*zend_object_call_method_t)(char const   *method , int ht ,
                                         zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used );
typedef union _zend_function *(*zend_object_get_method_t)(zval **object_ptr ,
                                                          char *method ,
                                                          int method_len ,
                                                          struct _zend_literal  const  *key );
typedef union _zend_function *(*zend_object_get_constructor_t)(zval *object );
typedef void (*zend_object_add_ref_t)(zval *object );
typedef void (*zend_object_del_ref_t)(zval *object );
typedef void (*zend_object_delete_obj_t)(zval *object );
typedef zend_object_value (*zend_object_clone_obj_t)(zval *object );
typedef zend_class_entry *(*zend_object_get_class_entry_t)(zval const   *object );
typedef int (*zend_object_get_class_name_t)(zval const   *object ,
                                            char const   **class_name ,
                                            zend_uint *class_name_len ,
                                            int parent );
typedef int (*zend_object_compare_t)(zval *object1 , zval *object2 );
typedef int (*zend_object_cast_t)(zval *readobj , zval *retval , int type );
typedef int (*zend_object_count_elements_t)(zval *object , long *count );
typedef int (*zend_object_get_closure_t)(zval *obj , zend_class_entry **ce_ptr ,
                                         union _zend_function **fptr_ptr ,
                                         zval **zobj_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 const   *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 const   **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 ) ;
};
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 ;
};
struct _zend_object_iterator;
typedef struct _zend_object_iterator zend_object_iterator;
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 ) ;
};
typedef struct _zend_object_iterator_funcs zend_object_iterator_funcs;
struct _zend_object_iterator {
   void *data ;
   zend_object_iterator_funcs *funcs ;
   ulong index ;
};
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;
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_serialize_data;
struct _zend_unserialize_data;
typedef struct _zend_serialize_data zend_serialize_data;
typedef struct _zend_unserialize_data zend_unserialize_data;
struct _zend_trait_method_reference {
   char const   *method_name ;
   unsigned int mname_len ;
   zend_class_entry *ce ;
   char const   *class_name ;
   unsigned int cname_len ;
};
typedef struct _zend_trait_method_reference zend_trait_method_reference;
struct _zend_trait_precedence {
   zend_trait_method_reference *trait_method ;
   zend_class_entry **exclude_from_classes ;
   union _zend_function *function ;
};
typedef struct _zend_trait_precedence zend_trait_precedence;
struct _zend_trait_alias {
   zend_trait_method_reference *trait_method ;
   char const   *alias ;
   unsigned int alias_len ;
   zend_uint modifiers ;
   union _zend_function *function ;
};
typedef struct _zend_trait_alias zend_trait_alias;
struct __anonstruct_user_41 {
   char const   *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char const   *doc_comment ;
   zend_uint doc_comment_len ;
};
struct _zend_function_entry;
struct _zend_module_entry;
struct __anonstruct_internal_42 {
   struct _zend_function_entry  const  *builtin_functions ;
   struct _zend_module_entry *module ;
};
union __anonunion_info_40 {
   struct __anonstruct_user_41 user ;
   struct __anonstruct_internal_42 internal ;
};
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 ;
};
typedef size_t (*zend_stream_fsizer_t)(void *handle );
typedef size_t (*zend_stream_reader_t)(void *handle , char *buf , size_t len );
typedef void (*zend_stream_closer_t)(void *handle );
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_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 ;
};
struct _zend_file_handle {
   zend_stream_type type ;
   char const   *filename ;
   char *opened_path ;
   union __anonunion_handle_44 handle ;
   zend_bool free_filename ;
};
typedef struct _zend_file_handle zend_file_handle;
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 const   *data ) ;
   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 ) ;
};
typedef struct _zend_utility_functions zend_utility_functions;
struct _zend_utility_values {
   char *import_use_extension ;
   uint import_use_extension_length ;
   zend_bool html_errors ;
};
typedef struct _zend_utility_values zend_utility_values;
typedef int (*zend_write_func_t)(char const   *str , uint str_length );
typedef __sig_atomic_t sig_atomic_t;
union sigval {
   int sival_int ;
   void *sival_ptr ;
};
typedef union sigval sigval_t;
struct __anonstruct__kill_46 {
   __pid_t si_pid ;
   __uid_t si_uid ;
};
struct __anonstruct__timer_47 {
   int si_tid ;
   int si_overrun ;
   sigval_t si_sigval ;
};
struct __anonstruct__rt_48 {
   __pid_t si_pid ;
   __uid_t si_uid ;
   sigval_t si_sigval ;
};
struct __anonstruct__sigchld_49 {
   __pid_t si_pid ;
   __uid_t si_uid ;
   int si_status ;
   __clock_t si_utime ;
   __clock_t si_stime ;
};
struct __anonstruct__sigfault_50 {
   void *si_addr ;
};
struct __anonstruct__sigpoll_51 {
   long si_band ;
   int si_fd ;
};
union __anonunion__sifields_45 {
   int _pad[128U / sizeof(int ) - 3U] ;
   struct __anonstruct__kill_46 _kill ;
   struct __anonstruct__timer_47 _timer ;
   struct __anonstruct__rt_48 _rt ;
   struct __anonstruct__sigchld_49 _sigchld ;
   struct __anonstruct__sigfault_50 _sigfault ;
   struct __anonstruct__sigpoll_51 _sigpoll ;
};
struct siginfo {
   int si_signo ;
   int si_errno ;
   int si_code ;
   union __anonunion__sifields_45 _sifields ;
};
typedef struct siginfo siginfo_t;
enum __anonenum_52 {
    SI_ASYNCNL = -60,
    SI_TKILL = -6,
    SI_SIGIO = -5,
    SI_ASYNCIO = -4,
    SI_MESGQ = -3,
    SI_TIMER = -2,
    SI_QUEUE = -1,
    SI_USER = 0,
    SI_KERNEL = 128
} ;
enum __anonenum_53 {
    ILL_ILLOPC = 1,
    ILL_ILLOPN = 2,
    ILL_ILLADR = 3,
    ILL_ILLTRP = 4,
    ILL_PRVOPC = 5,
    ILL_PRVREG = 6,
    ILL_COPROC = 7,
    ILL_BADSTK = 8
} ;
enum __anonenum_54 {
    FPE_INTDIV = 1,
    FPE_INTOVF = 2,
    FPE_FLTDIV = 3,
    FPE_FLTOVF = 4,
    FPE_FLTUND = 5,
    FPE_FLTRES = 6,
    FPE_FLTINV = 7,
    FPE_FLTSUB = 8
} ;
enum __anonenum_55 {
    SEGV_MAPERR = 1,
    SEGV_ACCERR = 2
} ;
enum __anonenum_56 {
    BUS_ADRALN = 1,
    BUS_ADRERR = 2,
    BUS_OBJERR = 3
} ;
enum __anonenum_57 {
    TRAP_BRKPT = 1,
    TRAP_TRACE = 2
} ;
enum __anonenum_58 {
    CLD_EXITED = 1,
    CLD_KILLED = 2,
    CLD_DUMPED = 3,
    CLD_TRAPPED = 4,
    CLD_STOPPED = 5,
    CLD_CONTINUED = 6
} ;
enum __anonenum_59 {
    POLL_IN = 1,
    POLL_OUT = 2,
    POLL_MSG = 3,
    POLL_ERR = 4,
    POLL_PRI = 5,
    POLL_HUP = 6
} ;
struct __anonstruct__sigev_thread_61 {
   void (*_function)(sigval_t  ) ;
   void *_attribute ;
};
union __anonunion__sigev_un_60 {
   int _pad[64U / sizeof(int ) - 3U] ;
   __pid_t _tid ;
   struct __anonstruct__sigev_thread_61 _sigev_thread ;
};
struct sigevent {
   sigval_t sigev_value ;
   int sigev_signo ;
   int sigev_notify ;
   union __anonunion__sigev_un_60 _sigev_un ;
};
typedef struct sigevent sigevent_t;
enum __anonenum_62 {
    SIGEV_SIGNAL = 0,
    SIGEV_NONE = 1,
    SIGEV_THREAD = 2,
    SIGEV_THREAD_ID = 4
} ;
typedef void (*__sighandler_t)(int  );
typedef void (*sighandler_t)(int  );
typedef void (*sig_t)(int  );
union __anonunion___sigaction_handler_63 {
   void (*sa_handler)(int  ) ;
   void (*sa_sigaction)(int  , siginfo_t * , void * ) ;
};
struct sigaction {
   union __anonunion___sigaction_handler_63 __sigaction_handler ;
   __sigset_t sa_mask ;
   int sa_flags ;
   void (*sa_restorer)(void) ;
};
struct sigvec {
   void (*sv_handler)(int  ) ;
   int sv_mask ;
   int sv_flags ;
};
typedef signed char __s8;
typedef unsigned char __u8;
typedef short __s16;
typedef unsigned short __u16;
typedef int __s32;
typedef unsigned int __u32;
typedef long long __s64;
typedef unsigned long long __u64;
typedef unsigned short umode_t;
struct __anonstruct___kernel_fd_set_64 {
   unsigned long fds_bits[1024U / (8U * sizeof(unsigned long ))] ;
};
typedef struct __anonstruct___kernel_fd_set_64 __kernel_fd_set;
typedef void (*__kernel_sighandler_t)(int  );
typedef int __kernel_key_t;
typedef int __kernel_mqd_t;
typedef unsigned long __kernel_ino_t;
typedef unsigned short __kernel_mode_t;
typedef unsigned short __kernel_nlink_t;
typedef long __kernel_off_t;
typedef int __kernel_pid_t;
typedef unsigned short __kernel_ipc_pid_t;
typedef unsigned short __kernel_uid_t;
typedef unsigned short __kernel_gid_t;
typedef unsigned int __kernel_size_t;
typedef int __kernel_ssize_t;
typedef int __kernel_ptrdiff_t;
typedef long __kernel_time_t;
typedef long __kernel_suseconds_t;
typedef long __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef int __kernel_daddr_t;
typedef char *__kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;
typedef unsigned short __kernel_old_dev_t;
typedef long long __kernel_loff_t;
struct __anonstruct___kernel_fsid_t_65 {
   int val[2] ;
};
typedef struct __anonstruct___kernel_fsid_t_65 __kernel_fsid_t;
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;
typedef __u16 __sum16;
typedef __u32 __wsum;
struct _fpx_sw_bytes {
   __u32 magic1 ;
   __u32 extended_size ;
   __u64 xstate_bv ;
   __u32 xstate_size ;
   __u32 padding[7] ;
};
struct _fpreg {
   unsigned short significand[4] ;
   unsigned short exponent ;
};
struct _fpxreg {
   unsigned short significand[4] ;
   unsigned short exponent ;
   unsigned short padding[3] ;
};
struct _xmmreg {
   unsigned long element[4] ;
};
union __anonunion____missing_field_name_66 {
   unsigned long padding2[12] ;
   struct _fpx_sw_bytes sw_reserved ;
};
struct _fpstate {
   unsigned long cw ;
   unsigned long sw ;
   unsigned long tag ;
   unsigned long ipoff ;
   unsigned long cssel ;
   unsigned long dataoff ;
   unsigned long datasel ;
   struct _fpreg _st[8] ;
   unsigned short status ;
   unsigned short magic ;
   unsigned long _fxsr_env[6] ;
   unsigned long mxcsr ;
   unsigned long reserved ;
   struct _fpxreg _fxsr_st[8] ;
   struct _xmmreg _xmm[8] ;
   unsigned long padding1[44] ;
   union __anonunion____missing_field_name_66 __annonCompField2 ;
};
struct sigcontext {
   unsigned short gs ;
   unsigned short __gsh ;
   unsigned short fs ;
   unsigned short __fsh ;
   unsigned short es ;
   unsigned short __esh ;
   unsigned short ds ;
   unsigned short __dsh ;
   unsigned long edi ;
   unsigned long esi ;
   unsigned long ebp ;
   unsigned long esp ;
   unsigned long ebx ;
   unsigned long edx ;
   unsigned long ecx ;
   unsigned long eax ;
   unsigned long trapno ;
   unsigned long err ;
   unsigned long eip ;
   unsigned short cs ;
   unsigned short __csh ;
   unsigned long eflags ;
   unsigned long esp_at_signal ;
   unsigned short ss ;
   unsigned short __ssh ;
   struct _fpstate *fpstate ;
   unsigned long oldmask ;
   unsigned long cr2 ;
};
struct _xsave_hdr {
   __u64 xstate_bv ;
   __u64 reserved1[2] ;
   __u64 reserved2[5] ;
};
struct _ymmh_state {
   __u32 ymmh_space[64] ;
};
struct _xstate {
   struct _fpstate fpstate ;
   struct _xsave_hdr xstate_hdr ;
   struct _ymmh_state ymmh ;
};
struct sigstack {
   void *ss_sp ;
   int ss_onstack ;
};
enum __anonenum_67 {
    SS_ONSTACK = 1,
    SS_DISABLE = 2
} ;
struct sigaltstack {
   void *ss_sp ;
   int ss_flags ;
   size_t ss_size ;
};
typedef struct sigaltstack stack_t;
typedef int greg_t;
typedef greg_t gregset_t[19];
enum __anonenum_68 {
    REG_GS = 0,
    REG_FS = 1,
    REG_ES = 2,
    REG_DS = 3,
    REG_EDI = 4,
    REG_ESI = 5,
    REG_EBP = 6,
    REG_ESP = 7,
    REG_EBX = 8,
    REG_EDX = 9,
    REG_ECX = 10,
    REG_EAX = 11,
    REG_TRAPNO = 12,
    REG_ERR = 13,
    REG_EIP = 14,
    REG_CS = 15,
    REG_EFL = 16,
    REG_UESP = 17,
    REG_SS = 18
} ;
struct _libc_fpreg {
   unsigned short significand[4] ;
   unsigned short exponent ;
};
struct _libc_fpstate {
   unsigned long cw ;
   unsigned long sw ;
   unsigned long tag ;
   unsigned long ipoff ;
   unsigned long cssel ;
   unsigned long dataoff ;
   unsigned long datasel ;
   struct _libc_fpreg _st[8] ;
   unsigned long status ;
};
typedef struct _libc_fpstate *fpregset_t;
struct __anonstruct_mcontext_t_69 {
   gregset_t gregs ;
   fpregset_t fpregs ;
   unsigned long oldmask ;
   unsigned long cr2 ;
};
typedef struct __anonstruct_mcontext_t_69 mcontext_t;
struct ucontext {
   unsigned long uc_flags ;
   struct ucontext *uc_link ;
   stack_t uc_stack ;
   mcontext_t uc_mcontext ;
   __sigset_t uc_sigmask ;
   struct _libc_fpstate __fpregs_mem ;
};
typedef struct ucontext ucontext_t;
struct _zend_signal_entry_t {
   int flags ;
   void *handler ;
};
typedef struct _zend_signal_entry_t zend_signal_entry_t;
struct _zend_signal_t {
   int signo ;
   siginfo_t *siginfo ;
   void *context ;
};
typedef struct _zend_signal_t zend_signal_t;
struct _zend_signal_queue_t {
   zend_signal_t zend_signal ;
   struct _zend_signal_queue_t *next ;
};
typedef struct _zend_signal_queue_t zend_signal_queue_t;
struct _zend_signal_globals_t {
   int depth ;
   int blocked ;
   int running ;
   int active ;
   int initialized ;
   zend_bool check ;
   zend_signal_entry_t handlers[65] ;
   zend_signal_queue_t pstorage[32] ;
   zend_signal_queue_t *phead ;
   zend_signal_queue_t *ptail ;
   zend_signal_queue_t *pavail ;
};
typedef struct _zend_signal_globals_t zend_signal_globals_t;
union __anonunion_u_70 {
   zval *pz ;
   zend_object_handlers const   *handlers ;
};
struct _gc_root_buffer {
   struct _gc_root_buffer *prev ;
   struct _gc_root_buffer *next ;
   zend_object_handle handle ;
   union __anonunion_u_70 u ;
};
typedef struct _gc_root_buffer gc_root_buffer;
struct _zval_gc_info;
union __anonunion_u_71 {
   gc_root_buffer *buffered ;
   struct _zval_gc_info *next ;
};
struct _zval_gc_info {
   zval z ;
   union __anonunion_u_71 u ;
};
typedef struct _zval_gc_info zval_gc_info;
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 ;
};
typedef struct _zend_gc_globals zend_gc_globals;
typedef int error_t;
enum __anonenum_zend_error_handling_t_72 {
    EH_NORMAL = 0,
    EH_SUPPRESS = 1,
    EH_THROW = 2
} ;
typedef enum __anonenum_zend_error_handling_t_72 zend_error_handling_t;
struct __anonstruct_zend_error_handling_73 {
   zend_error_handling_t handling ;
   zend_class_entry *exception ;
   zval *user_handler ;
};
typedef struct __anonstruct_zend_error_handling_73 zend_error_handling;
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];
typedef struct __jmp_buf_tag sigjmp_buf[1];
struct _zend_compiler_globals;
typedef struct _zend_compiler_globals zend_compiler_globals;
struct _zend_executor_globals;
typedef struct _zend_executor_globals zend_executor_globals;
struct _zend_php_scanner_globals;
typedef struct _zend_php_scanner_globals zend_php_scanner_globals;
struct _zend_ini_scanner_globals;
typedef struct _zend_ini_scanner_globals zend_ini_scanner_globals;
struct _zend_stack {
   int top ;
   int max ;
   void **elements ;
};
typedef struct _zend_stack zend_stack;
struct _zend_ptr_stack {
   int top ;
   int max ;
   void **elements ;
   void **top_element ;
   zend_bool persistent ;
};
typedef struct _zend_ptr_stack zend_ptr_stack;
typedef void (*zend_objects_store_dtor_t)(void *object ,
                                          zend_object_handle handle );
typedef void (*zend_objects_free_object_storage_t)(void *object );
typedef void (*zend_objects_store_clone_t)(void *object , void **object_clone );
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 ;
};
struct __anonstruct_free_list_74 {
   int next ;
};
union _store_bucket {
   struct _store_object obj ;
   struct __anonstruct_free_list_74 free_list ;
};
struct _zend_object_store_bucket {
   zend_bool destructor_called ;
   zend_bool valid ;
   union _store_bucket 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_op_array;
typedef struct _zend_op_array zend_op_array;
struct _zend_op;
typedef struct _zend_op zend_op;
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;
struct _zend_literal {
   zval constant ;
   zend_ulong hash_value ;
   zend_uint cache_slot ;
};
typedef struct _zend_literal zend_literal;
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;
union __anonunion_u_75 {
   znode_op op ;
   zval constant ;
   zend_op_array *op_array ;
};
struct _znode {
   int op_type ;
   union __anonunion_u_75 u ;
   zend_uint EA ;
};
typedef struct _znode znode;
struct _zend_execute_data;
typedef struct _zend_execute_data zend_execute_data;
typedef int (*user_opcode_handler_t)(zend_execute_data *execute_data );
typedef int ( __attribute__((__fastcall__)) (*opcode_handler_t))(zend_execute_data *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_brk_cont_element {
   int start ;
   int cont ;
   int brk ;
   int parent ;
};
typedef struct _zend_brk_cont_element zend_brk_cont_element;
struct _zend_label {
   int brk_cont ;
   zend_uint opline_num ;
};
typedef struct _zend_label zend_label;
struct _zend_try_catch_element {
   zend_uint try_op ;
   zend_uint catch_op ;
};
typedef struct _zend_try_catch_element zend_try_catch_element;
struct _zend_property_info {
   zend_uint flags ;
   char const   *name ;
   int name_length ;
   ulong h ;
   int offset ;
   char const   *doc_comment ;
   int doc_comment_len ;
   zend_class_entry *ce ;
};
typedef struct _zend_property_info zend_property_info;
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;
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 ;
};
typedef struct _zend_internal_function_info zend_internal_function_info;
struct _zend_compiled_variable {
   char const   *name ;
   int name_len ;
   ulong hash_value ;
};
typedef struct _zend_compiled_variable zend_compiled_variable;
struct _zend_op_array {
   zend_uchar type ;
   char const   *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 const   *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char const   *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 _zend_internal_function {
   zend_uchar type ;
   char const   *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 __anonstruct_common_76 {
   zend_uchar type ;
   char const   *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_76 common ;
   zend_op_array op_array ;
   zend_internal_function internal_function ;
};
typedef union _zend_function zend_function;
struct _zend_function_state {
   zend_function *function ;
   void **arguments ;
};
typedef struct _zend_function_state zend_function_state;
struct _zend_switch_entry {
   znode cond ;
   int default_case ;
   int control_var ;
};
typedef struct _zend_switch_entry zend_switch_entry;
struct _list_llist_element {
   znode var ;
   zend_llist dimensions ;
   znode value ;
};
typedef struct _list_llist_element list_llist_element;
union _temp_variable;
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 ;
};
typedef int (*unary_op_type)(zval * , zval * );
typedef int (*binary_op_type)(zval * , zval * , zval * );
typedef zend_bool (*zend_auto_global_callback)(char const   *name ,
                                               uint name_len );
struct _zend_auto_global {
   char const   *name ;
   uint name_len ;
   zend_bool (*auto_global_callback)(char const   *name , uint name_len ) ;
   zend_bool jit ;
   zend_bool armed ;
};
typedef struct _zend_auto_global zend_auto_global;
struct _zend_ini_entry;
typedef struct _zend_module_entry zend_module_entry;
struct _zend_module_dep;
typedef struct _zend_module_dep 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 ;
};
struct _zend_module_dep {
   char const   *name ;
   char const   *rel ;
   char const   *version ;
   unsigned char type ;
};
typedef unsigned short fpu_control_t;
struct _zend_encoding;
typedef struct _zend_encoding zend_encoding;
typedef size_t (*zend_encoding_filter)(unsigned char **str ,
                                       size_t *str_length ,
                                       unsigned char const   *buf ,
                                       size_t length );
typedef zend_encoding const   *(*zend_encoding_fetcher)(char const   *encoding_name );
typedef char const   *(*zend_encoding_name_getter)(zend_encoding const   *encoding );
typedef int (*zend_encoding_lexer_compatibility_checker)(zend_encoding const   *encoding );
typedef zend_encoding const   *(*zend_encoding_detector)(unsigned char const   *string ,
                                                         size_t length ,
                                                         zend_encoding const   **list ,
                                                         size_t list_size );
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 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 zend_encoding const   *(*zend_encoding_internal_encoding_getter)(void);
typedef int (*zend_encoding_internal_encoding_setter)(zend_encoding const   *encoding );
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 struct _zend_multibyte_functions zend_multibyte_functions;
struct _zend_declarables {
   zval ticks ;
};
typedef struct _zend_declarables zend_declarables;
struct _zend_vm_stack;
typedef struct _zend_vm_stack *zend_vm_stack;
typedef struct _zend_ini_entry zend_ini_entry;
struct _zend_ini_parser_param;
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 parse_error ;
   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_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] ;
};
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_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_rsrc_list_entry {
   void *ptr ;
   int type ;
   int refcount ;
};
typedef struct _zend_rsrc_list_entry zend_rsrc_list_entry;
typedef void (*rsrc_dtor_func_t)(zend_rsrc_list_entry *rsrc );
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 struct _zend_rsrc_list_dtors_entry zend_rsrc_list_dtors_entry;
struct __anonstruct_var_77 {
   zval **ptr_ptr ;
   zval *ptr ;
   zend_bool fcall_returned_reference ;
};
struct __anonstruct_str_offset_78 {
   zval **ptr_ptr ;
   zval *str ;
   zend_uint offset ;
};
struct __anonstruct_fe_79 {
   zval **ptr_ptr ;
   zval *ptr ;
   HashPointer fe_pos ;
};
union _temp_variable {
   zval tmp_var ;
   struct __anonstruct_var_77 var ;
   struct __anonstruct_str_offset_78 str_offset ;
   struct __anonstruct_fe_79 fe ;
   zend_class_entry *class_entry ;
};
typedef union _temp_variable temp_variable;
struct _zend_vm_stack {
   void **top ;
   void **end ;
   zend_vm_stack prev ;
};
struct _zend_free_op {
   zval *var ;
};
typedef struct _zend_free_op zend_free_op;
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_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 ;
};
typedef struct _zend_fcall_info zend_fcall_info;
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 ;
};
typedef struct _zend_fcall_info_cache zend_fcall_info_cache;
struct _zend_user_iterator {
   zend_object_iterator it ;
   zend_class_entry *ce ;
   zval *value ;
};
typedef struct _zend_user_iterator zend_user_iterator;
extern  __attribute__((__nothrow__)) size_t __ctype_get_mb_cur_max(void) ;
__inline extern  __attribute__((__nothrow__)) double atof(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) int atoi(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) long atol(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) long long atoll(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) double strtod(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__)) long double strtold(char const   * __restrict  __nptr ,
                                                         char ** __restrict  __endptr )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long strtol(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 long strtoq(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 strtoll(char const   * __restrict  __nptr ,
                                                       char ** __restrict  __endptr ,
                                                       int __base )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) unsigned long long strtoull(char const   * __restrict  __nptr ,
                                                                 char ** __restrict  __endptr ,
                                                                 int __base )  __attribute__((__nonnull__(1))) ;
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 strtoul_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 long strtoull_l(char const   * __restrict  __nptr ,
                                                                   char ** __restrict  __endptr ,
                                                                   int __base ,
                                                                   __locale_t __loc )  __attribute__((__nonnull__(1,4))) ;
extern  __attribute__((__nothrow__)) double strtod_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__)) long double strtold_l(char const   * __restrict  __nptr ,
                                                           char ** __restrict  __endptr ,
                                                           __locale_t __loc )  __attribute__((__nonnull__(1,3))) ;
extern FILE *fopen(char const   * __restrict  __filename ,
                   char const   * __restrict  __modes ) ;
extern int fprintf(FILE * __restrict  __stream ,
                   char const   * __restrict  __format  , ...) ;
extern int fflush(FILE *__stream ) ;
extern int fclose(FILE *__stream ) ;
__inline extern  __attribute__((__nothrow__)) double atof(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern double atof(char const   *__nptr ) 
{ double tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3786] == 0) {
    {
    fprintf(_coverage_fout, "3786\n");
    fflush(_coverage_fout);
    ___coverage_array[3786] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = strtod((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3787] == 0) {
    {
    fprintf(_coverage_fout, "3787\n");
    fflush(_coverage_fout);
    ___coverage_array[3787] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int atoi(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern int atoi(char const   *__nptr ) 
{ long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3788] == 0) {
    {
    fprintf(_coverage_fout, "3788\n");
    fflush(_coverage_fout);
    ___coverage_array[3788] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = strtol((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3789] == 0) {
    {
    fprintf(_coverage_fout, "3789\n");
    fflush(_coverage_fout);
    ___coverage_array[3789] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long atol(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern long atol(char const   *__nptr ) 
{ long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3790] == 0) {
    {
    fprintf(_coverage_fout, "3790\n");
    fflush(_coverage_fout);
    ___coverage_array[3790] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = strtol((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3791] == 0) {
    {
    fprintf(_coverage_fout, "3791\n");
    fflush(_coverage_fout);
    ___coverage_array[3791] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3792] == 0) {
    {
    fprintf(_coverage_fout, "3792\n");
    fflush(_coverage_fout);
    ___coverage_array[3792] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = strtoll((char const   */* __restrict  */)__nptr,
                (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3793] == 0) {
    {
    fprintf(_coverage_fout, "3793\n");
    fflush(_coverage_fout);
    ___coverage_array[3793] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern  __attribute__((__nothrow__)) char *l64a(long __n ) ;
extern  __attribute__((__nothrow__)) long a64l(char const   *__s )  __attribute__((__pure__,
__nonnull__(1))) ;
extern int select(int __nfds , fd_set * __restrict  __readfds ,
                  fd_set * __restrict  __writefds ,
                  fd_set * __restrict  __exceptfds ,
                  struct timeval * __restrict  __timeout ) ;
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 ) ;
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_major(unsigned long long __dev ) ;
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_minor(unsigned long long __dev ) ;
__inline extern  __attribute__((__nothrow__)) unsigned long long gnu_dev_makedev(unsigned int __major ,
                                                                                 unsigned int __minor ) ;
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_major(unsigned long long __dev ) ;
__inline extern unsigned int gnu_dev_major(unsigned long long __dev ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3794] == 0) {
    {
    fprintf(_coverage_fout, "3794\n");
    fflush(_coverage_fout);
    ___coverage_array[3794] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((unsigned int )(((__dev >> 8) & 4095ULL) | (unsigned long long )((unsigned int )(__dev >> 32) & 4294963200U)));
}
}
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_minor(unsigned long long __dev ) ;
__inline extern unsigned int gnu_dev_minor(unsigned long long __dev ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3795] == 0) {
    {
    fprintf(_coverage_fout, "3795\n");
    fflush(_coverage_fout);
    ___coverage_array[3795] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((unsigned int )((__dev & 255ULL) | (unsigned long long )((unsigned int )(__dev >> 12) & 4294967040U)));
}
}
__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 ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3796] == 0) {
    {
    fprintf(_coverage_fout, "3796\n");
    fflush(_coverage_fout);
    ___coverage_array[3796] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (((unsigned long long )((__minor & 255U) | ((__major & 4095U) << 8)) | ((unsigned long long )(__minor & 4294967040U) << 12)) | ((unsigned long long )(__major & 4294963200U) << 32));
}
}
extern  __attribute__((__nothrow__)) long random(void) ;
extern  __attribute__((__nothrow__)) void srandom(unsigned int __seed ) ;
extern  __attribute__((__nothrow__)) char *initstate(unsigned int __seed ,
                                                     char *__statebuf ,
                                                     size_t __statelen )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *setstate(char *__statebuf )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int random_r(struct random_data * __restrict  __buf ,
                                                  int32_t * __restrict  __result )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int srandom_r(unsigned int __seed ,
                                                   struct random_data *__buf )  __attribute__((__nonnull__(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 setstate_r(char * __restrict  __statebuf ,
                                                    struct random_data * __restrict  __buf )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int rand(void) ;
extern  __attribute__((__nothrow__)) void srand(unsigned int __seed ) ;
extern  __attribute__((__nothrow__)) int rand_r(unsigned int *__seed ) ;
extern  __attribute__((__nothrow__)) double drand48(void) ;
extern  __attribute__((__nothrow__)) double erand48(unsigned short *__xsubi )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long lrand48(void) ;
extern  __attribute__((__nothrow__)) long nrand48(unsigned short *__xsubi )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long mrand48(void) ;
extern  __attribute__((__nothrow__)) long jrand48(unsigned short *__xsubi )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void srand48(long __seedval ) ;
extern  __attribute__((__nothrow__)) unsigned short *seed48(unsigned short *__seed16v )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void lcong48(unsigned short *__param )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int drand48_r(struct drand48_data * __restrict  __buffer ,
                                                   double * __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 lrand48_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 mrand48_r(struct drand48_data * __restrict  __buffer ,
                                                   long * __restrict  __result )  __attribute__((__nonnull__(1,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 srand48_r(long __seedval ,
                                                   struct drand48_data *__buffer )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int seed48_r(unsigned short *__seed16v ,
                                                  struct drand48_data *__buffer )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int lcong48_r(unsigned short *__param ,
                                                   struct drand48_data *__buffer )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *malloc(size_t __size )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) void *calloc(size_t __nmemb ,
                                                  size_t __size )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) void *realloc(void *__ptr , size_t __size )  __attribute__((__warn_unused_result__)) ;
extern  __attribute__((__nothrow__)) void free(void *__ptr ) ;
extern  __attribute__((__nothrow__)) void cfree(void *__ptr ) ;
extern  __attribute__((__nothrow__)) void *alloca(size_t __size ) ;
extern  __attribute__((__nothrow__)) void *valloc(size_t __size )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) int posix_memalign(void **__memptr ,
                                                        size_t __alignment ,
                                                        size_t __size )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__, __noreturn__)) void abort(void) ;
extern  __attribute__((__nothrow__)) int atexit(void (*__func)(void) )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int at_quick_exit(void (*__func)(void) )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int on_exit(void (*__func)(int __status ,
                                                                void *__arg ) ,
                                                 void *__arg )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__, __noreturn__)) void exit(int __status ) ;
extern  __attribute__((__nothrow__,
__noreturn__)) void quick_exit(int __status ) ;
extern  __attribute__((__nothrow__, __noreturn__)) void _Exit(int __status ) ;
extern  __attribute__((__nothrow__)) char *getenv(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *__secure_getenv(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int putenv(char *__string )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int setenv(char const   *__name ,
                                                char const   *__value ,
                                                int __replace )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int unsetenv(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int clearenv(void) ;
extern  __attribute__((__nothrow__)) char *mktemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern int mkstemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern int mkstemp64(char *__template )  __attribute__((__nonnull__(1))) ;
extern int mkstemps(char *__template , int __suffixlen )  __attribute__((__nonnull__(1))) ;
extern int mkstemps64(char *__template , int __suffixlen )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *mkdtemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern int mkostemp(char *__template , int __flags )  __attribute__((__nonnull__(1))) ;
extern int mkostemp64(char *__template , int __flags )  __attribute__((__nonnull__(1))) ;
extern int mkostemps(char *__template , int __suffixlen , int __flags )  __attribute__((__nonnull__(1))) ;
extern int mkostemps64(char *__template , int __suffixlen , int __flags )  __attribute__((__nonnull__(1))) ;
extern int system(char const   *__command ) ;
extern  __attribute__((__nothrow__)) char *canonicalize_file_name(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *realpath(char const   * __restrict  __name ,
                                                    char * __restrict  __resolved ) ;
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 void qsort(void *__base , size_t __nmemb , size_t __size ,
                  int (*__compar)(void const   * , void const   * ) )  __attribute__((__nonnull__(1,4))) ;
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  __attribute__((__nothrow__)) int abs(int __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long labs(long __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long long llabs(long long __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) div_t div(int __numer , int __denom )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) ldiv_t ldiv(long __numer , long __denom )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) lldiv_t lldiv(long long __numer ,
                                                   long long __denom )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) char *ecvt(double __value , int __ndigit ,
                                                int * __restrict  __decpt ,
                                                int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
extern  __attribute__((__nothrow__)) char *fcvt(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 *qecvt(long double __value ,
                                                 int __ndigit ,
                                                 int * __restrict  __decpt ,
                                                 int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
extern  __attribute__((__nothrow__)) char *qfcvt(long double __value ,
                                                 int __ndigit ,
                                                 int * __restrict  __decpt ,
                                                 int * __restrict  __sign )  __attribute__((__nonnull__(3,4))) ;
extern  __attribute__((__nothrow__)) char *qgcvt(long double __value ,
                                                 int __ndigit , char *__buf )  __attribute__((__nonnull__(3))) ;
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__)) 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 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 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 mblen(char const   *__s , size_t __n ) ;
extern  __attribute__((__nothrow__)) int mbtowc(wchar_t * __restrict  __pwc ,
                                                char const   * __restrict  __s ,
                                                size_t __n ) ;
extern  __attribute__((__nothrow__)) int wctomb(char *__s , wchar_t __wchar ) ;
extern  __attribute__((__nothrow__)) size_t mbstowcs(wchar_t * __restrict  __pwcs ,
                                                     char const   * __restrict  __s ,
                                                     size_t __n ) ;
extern  __attribute__((__nothrow__)) size_t wcstombs(char * __restrict  __s ,
                                                     wchar_t const   * __restrict  __pwcs ,
                                                     size_t __n ) ;
extern  __attribute__((__nothrow__)) int rpmatch(char const   *__response )  __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__)) void setkey(char const   *__key )  __attribute__((__nonnull__(1))) ;
extern int posix_openpt(int __oflag ) ;
extern  __attribute__((__nothrow__)) int grantpt(int __fd ) ;
extern  __attribute__((__nothrow__)) int unlockpt(int __fd ) ;
extern  __attribute__((__nothrow__)) char *ptsname(int __fd ) ;
extern  __attribute__((__nothrow__)) int ptsname_r(int __fd , char *__buf ,
                                                   size_t __buflen )  __attribute__((__nonnull__(2))) ;
extern int getpt(void) ;
extern  __attribute__((__nothrow__)) int getloadavg(double *__loadavg ,
                                                    int __nelem )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *memcpy(void * __restrict  __dest ,
                                                  void const   * __restrict  __src ,
                                                  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 *memccpy(void * __restrict  __dest ,
                                                   void const   * __restrict  __src ,
                                                   int __c , size_t __n )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) void *memset(void *__s , int __c ,
                                                  size_t __n )  __attribute__((__nonnull__(1))) ;
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))) ;
extern  __attribute__((__nothrow__)) void *rawmemchr(void const   *__s ,
                                                     int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *memrchr(void const   *__s , int __c ,
                                                   size_t __n )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strcpy(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 *strcat(char * __restrict  __dest ,
                                                  char const   * __restrict  __src )  __attribute__((__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__)) int strcmp(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 strcoll(char const   *__s1 ,
                                                 char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) size_t strxfrm(char * __restrict  __dest ,
                                                    char const   * __restrict  __src ,
                                                    size_t __n )  __attribute__((__nonnull__(2))) ;
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_l(char *__dest ,
                                                      char const   *__src ,
                                                      size_t __n ,
                                                      __locale_t __l )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) char *strdup(char const   *__s )  __attribute__((__nonnull__(1),
__malloc__)) ;
extern  __attribute__((__nothrow__)) char *strndup(char const   *__string ,
                                                   size_t __n )  __attribute__((__nonnull__(1),
__malloc__)) ;
extern  __attribute__((__nothrow__)) char *strchr(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 *strchrnul(char const   *__s ,
                                                     int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) size_t strcspn(char const   *__s ,
                                                    char const   *__reject )  __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__)) char *strpbrk(char const   *__s ,
                                                   char const   *__accept )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strstr(char const   *__haystack ,
                                                  char const   *__needle )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strtok(char * __restrict  __s ,
                                                  char const   * __restrict  __delim )  __attribute__((__nonnull__(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 *strcasestr(char const   *__haystack ,
                                                      char const   *__needle )  __attribute__((__pure__,
__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__)) 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__)) size_t strlen(char const   *__s )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) size_t strnlen(char const   *__string ,
                                                    size_t __maxlen )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *strerror(int __errnum ) ;
extern  __attribute__((__nothrow__)) char *strerror_r(int __errnum ,
                                                      char *__buf ,
                                                      size_t __buflen )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) char *strerror_l(int __errnum ,
                                                      __locale_t __l ) ;
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__)) int bcmp(void const   *__s1 ,
                                              void const   *__s2 , size_t __n )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *index(char const   *__s , int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *rindex(char const   *__s , int __c )  __attribute__((__pure__,
__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int ffs(int __i )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int ffsl(long __l )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int ffsll(long long __ll )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int strcasecmp(char const   *__s1 ,
                                                    char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int strncasecmp(char const   *__s1 ,
                                                     char const   *__s2 ,
                                                     size_t __n )  __attribute__((__pure__,
__nonnull__(1,2))) ;
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 strncasecmp_l(char const   *__s1 ,
                                                       char const   *__s2 ,
                                                       size_t __n ,
                                                       __locale_t __loc )  __attribute__((__pure__,
__nonnull__(1,2,4))) ;
extern  __attribute__((__nothrow__)) char *strsep(char ** __restrict  __stringp ,
                                                  char const   * __restrict  __delim )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strsignal(int __sig ) ;
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 *__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__)) int strverscmp(char const   *__s1 ,
                                                    char const   *__s2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) char *strfry(char *__string )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *memfrob(void *__s , size_t __n )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *basename(char const   *__filename )  __attribute__((__nonnull__(1))) ;
extern void *__rawmemchr(void const   *__s , int __c ) ;
__inline extern size_t __strcspn_c1(char const   *__s , int __reject ) ;
__inline extern size_t __strcspn_c1(char const   *__s , int __reject ) 
{ register size_t __result ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3801] == 0) {
    {
    fprintf(_coverage_fout, "3801\n");
    fflush(_coverage_fout);
    ___coverage_array[3801] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3802] == 0) {
    {
    fprintf(_coverage_fout, "3802\n");
    fflush(_coverage_fout);
    ___coverage_array[3802] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3799] == 0) {
      {
      fprintf(_coverage_fout, "3799\n");
      fflush(_coverage_fout);
      ___coverage_array[3799] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3798] == 0) {
        {
        fprintf(_coverage_fout, "3798\n");
        fflush(_coverage_fout);
        ___coverage_array[3798] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3797] == 0) {
          {
          fprintf(_coverage_fout, "3797\n");
          fflush(_coverage_fout);
          ___coverage_array[3797] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3800] == 0) {
      {
      fprintf(_coverage_fout, "3800\n");
      fflush(_coverage_fout);
      ___coverage_array[3800] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3803] == 0) {
    {
    fprintf(_coverage_fout, "3803\n");
    fflush(_coverage_fout);
    ___coverage_array[3803] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strcspn_c2(char const   *__s , int __reject1 ,
                                    int __reject2 ) ;
__inline extern size_t __strcspn_c2(char const   *__s , int __reject1 ,
                                    int __reject2 ) 
{ register size_t __result ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3809] == 0) {
    {
    fprintf(_coverage_fout, "3809\n");
    fflush(_coverage_fout);
    ___coverage_array[3809] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3810] == 0) {
    {
    fprintf(_coverage_fout, "3810\n");
    fflush(_coverage_fout);
    ___coverage_array[3810] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3807] == 0) {
      {
      fprintf(_coverage_fout, "3807\n");
      fflush(_coverage_fout);
      ___coverage_array[3807] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3806] == 0) {
        {
        fprintf(_coverage_fout, "3806\n");
        fflush(_coverage_fout);
        ___coverage_array[3806] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3805] == 0) {
          {
          fprintf(_coverage_fout, "3805\n");
          fflush(_coverage_fout);
          ___coverage_array[3805] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3804] == 0) {
            {
            fprintf(_coverage_fout, "3804\n");
            fflush(_coverage_fout);
            ___coverage_array[3804] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3808] == 0) {
      {
      fprintf(_coverage_fout, "3808\n");
      fflush(_coverage_fout);
      ___coverage_array[3808] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3811] == 0) {
    {
    fprintf(_coverage_fout, "3811\n");
    fflush(_coverage_fout);
    ___coverage_array[3811] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strcspn_c3(char const   *__s , int __reject1 ,
                                    int __reject2 , int __reject3 ) ;
__inline extern size_t __strcspn_c3(char const   *__s , int __reject1 ,
                                    int __reject2 , int __reject3 ) 
{ register size_t __result ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3818] == 0) {
    {
    fprintf(_coverage_fout, "3818\n");
    fflush(_coverage_fout);
    ___coverage_array[3818] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3819] == 0) {
    {
    fprintf(_coverage_fout, "3819\n");
    fflush(_coverage_fout);
    ___coverage_array[3819] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3816] == 0) {
      {
      fprintf(_coverage_fout, "3816\n");
      fflush(_coverage_fout);
      ___coverage_array[3816] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3815] == 0) {
        {
        fprintf(_coverage_fout, "3815\n");
        fflush(_coverage_fout);
        ___coverage_array[3815] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3814] == 0) {
          {
          fprintf(_coverage_fout, "3814\n");
          fflush(_coverage_fout);
          ___coverage_array[3814] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3813] == 0) {
            {
            fprintf(_coverage_fout, "3813\n");
            fflush(_coverage_fout);
            ___coverage_array[3813] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*(__s + __result) != (int const   )__reject3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3812] == 0) {
              {
              fprintf(_coverage_fout, "3812\n");
              fflush(_coverage_fout);
              ___coverage_array[3812] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3817] == 0) {
      {
      fprintf(_coverage_fout, "3817\n");
      fflush(_coverage_fout);
      ___coverage_array[3817] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3820] == 0) {
    {
    fprintf(_coverage_fout, "3820\n");
    fflush(_coverage_fout);
    ___coverage_array[3820] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strspn_c1(char const   *__s , int __accept ) ;
__inline extern size_t __strspn_c1(char const   *__s , int __accept ) 
{ register size_t __result ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3824] == 0) {
    {
    fprintf(_coverage_fout, "3824\n");
    fflush(_coverage_fout);
    ___coverage_array[3824] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3825] == 0) {
    {
    fprintf(_coverage_fout, "3825\n");
    fflush(_coverage_fout);
    ___coverage_array[3825] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3822] == 0) {
      {
      fprintf(_coverage_fout, "3822\n");
      fflush(_coverage_fout);
      ___coverage_array[3822] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3821] == 0) {
        {
        fprintf(_coverage_fout, "3821\n");
        fflush(_coverage_fout);
        ___coverage_array[3821] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3823] == 0) {
      {
      fprintf(_coverage_fout, "3823\n");
      fflush(_coverage_fout);
      ___coverage_array[3823] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3826] == 0) {
    {
    fprintf(_coverage_fout, "3826\n");
    fflush(_coverage_fout);
    ___coverage_array[3826] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strspn_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) ;
__inline extern size_t __strspn_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) 
{ register size_t __result ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3832] == 0) {
    {
    fprintf(_coverage_fout, "3832\n");
    fflush(_coverage_fout);
    ___coverage_array[3832] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3833] == 0) {
    {
    fprintf(_coverage_fout, "3833\n");
    fflush(_coverage_fout);
    ___coverage_array[3833] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3830] == 0) {
      {
      fprintf(_coverage_fout, "3830\n");
      fflush(_coverage_fout);
      ___coverage_array[3830] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3827] == 0) {
        {
        fprintf(_coverage_fout, "3827\n");
        fflush(_coverage_fout);
        ___coverage_array[3827] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3829] == 0) {
        {
        fprintf(_coverage_fout, "3829\n");
        fflush(_coverage_fout);
        ___coverage_array[3829] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) == (int const   )__accept2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3828] == 0) {
          {
          fprintf(_coverage_fout, "3828\n");
          fflush(_coverage_fout);
          ___coverage_array[3828] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3831] == 0) {
      {
      fprintf(_coverage_fout, "3831\n");
      fflush(_coverage_fout);
      ___coverage_array[3831] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3834] == 0) {
    {
    fprintf(_coverage_fout, "3834\n");
    fflush(_coverage_fout);
    ___coverage_array[3834] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
__inline extern size_t __strspn_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) ;
__inline extern size_t __strspn_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) 
{ register size_t __result ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3842] == 0) {
    {
    fprintf(_coverage_fout, "3842\n");
    fflush(_coverage_fout);
    ___coverage_array[3842] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3843] == 0) {
    {
    fprintf(_coverage_fout, "3843\n");
    fflush(_coverage_fout);
    ___coverage_array[3843] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3840] == 0) {
      {
      fprintf(_coverage_fout, "3840\n");
      fflush(_coverage_fout);
      ___coverage_array[3840] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3835] == 0) {
        {
        fprintf(_coverage_fout, "3835\n");
        fflush(_coverage_fout);
        ___coverage_array[3835] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3839] == 0) {
        {
        fprintf(_coverage_fout, "3839\n");
        fflush(_coverage_fout);
        ___coverage_array[3839] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) == (int const   )__accept2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3836] == 0) {
          {
          fprintf(_coverage_fout, "3836\n");
          fflush(_coverage_fout);
          ___coverage_array[3836] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3838] == 0) {
          {
          fprintf(_coverage_fout, "3838\n");
          fflush(_coverage_fout);
          ___coverage_array[3838] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(__s + __result) == (int const   )__accept3) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3837] == 0) {
            {
            fprintf(_coverage_fout, "3837\n");
            fflush(_coverage_fout);
            ___coverage_array[3837] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3841] == 0) {
      {
      fprintf(_coverage_fout, "3841\n");
      fflush(_coverage_fout);
      ___coverage_array[3841] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3844] == 0) {
    {
    fprintf(_coverage_fout, "3844\n");
    fflush(_coverage_fout);
    ___coverage_array[3844] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
__inline extern char *__strpbrk_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) ;
__inline extern char *__strpbrk_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) 
{ char *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3852] == 0) {
    {
    fprintf(_coverage_fout, "3852\n");
    fflush(_coverage_fout);
    ___coverage_array[3852] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3848] == 0) {
      {
      fprintf(_coverage_fout, "3848\n");
      fflush(_coverage_fout);
      ___coverage_array[3848] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3847] == 0) {
        {
        fprintf(_coverage_fout, "3847\n");
        fflush(_coverage_fout);
        ___coverage_array[3847] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3846] == 0) {
          {
          fprintf(_coverage_fout, "3846\n");
          fflush(_coverage_fout);
          ___coverage_array[3846] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3845] == 0) {
            {
            fprintf(_coverage_fout, "3845\n");
            fflush(_coverage_fout);
            ___coverage_array[3845] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3849] == 0) {
      {
      fprintf(_coverage_fout, "3849\n");
      fflush(_coverage_fout);
      ___coverage_array[3849] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3853] == 0) {
    {
    fprintf(_coverage_fout, "3853\n");
    fflush(_coverage_fout);
    ___coverage_array[3853] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3850] == 0) {
      {
      fprintf(_coverage_fout, "3850\n");
      fflush(_coverage_fout);
      ___coverage_array[3850] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3851] == 0) {
      {
      fprintf(_coverage_fout, "3851\n");
      fflush(_coverage_fout);
      ___coverage_array[3851] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3854] == 0) {
    {
    fprintf(_coverage_fout, "3854\n");
    fflush(_coverage_fout);
    ___coverage_array[3854] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern char *__strpbrk_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) ;
__inline extern char *__strpbrk_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) 
{ char *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3863] == 0) {
    {
    fprintf(_coverage_fout, "3863\n");
    fflush(_coverage_fout);
    ___coverage_array[3863] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3859] == 0) {
      {
      fprintf(_coverage_fout, "3859\n");
      fflush(_coverage_fout);
      ___coverage_array[3859] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3858] == 0) {
        {
        fprintf(_coverage_fout, "3858\n");
        fflush(_coverage_fout);
        ___coverage_array[3858] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3857] == 0) {
          {
          fprintf(_coverage_fout, "3857\n");
          fflush(_coverage_fout);
          ___coverage_array[3857] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3856] == 0) {
            {
            fprintf(_coverage_fout, "3856\n");
            fflush(_coverage_fout);
            ___coverage_array[3856] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*__s != (int const   )__accept3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3855] == 0) {
              {
              fprintf(_coverage_fout, "3855\n");
              fflush(_coverage_fout);
              ___coverage_array[3855] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3860] == 0) {
      {
      fprintf(_coverage_fout, "3860\n");
      fflush(_coverage_fout);
      ___coverage_array[3860] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3864] == 0) {
    {
    fprintf(_coverage_fout, "3864\n");
    fflush(_coverage_fout);
    ___coverage_array[3864] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3861] == 0) {
      {
      fprintf(_coverage_fout, "3861\n");
      fflush(_coverage_fout);
      ___coverage_array[3861] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3862] == 0) {
      {
      fprintf(_coverage_fout, "3862\n");
      fflush(_coverage_fout);
      ___coverage_array[3862] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3865] == 0) {
    {
    fprintf(_coverage_fout, "3865\n");
    fflush(_coverage_fout);
    ___coverage_array[3865] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern char *__strtok_r_1c(char *__s , char __sep , char **__nextp ) ;
__inline extern char *__strtok_r_1c(char *__s , char __sep , char **__nextp ) 
{ char *__result ;
  char *tmp ;
  char *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3883] == 0) {
    {
    fprintf(_coverage_fout, "3883\n");
    fflush(_coverage_fout);
    ___coverage_array[3883] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__s == (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3866] == 0) {
      {
      fprintf(_coverage_fout, "3866\n");
      fflush(_coverage_fout);
      ___coverage_array[3866] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = *__nextp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3867] == 0) {
      {
      fprintf(_coverage_fout, "3867\n");
      fflush(_coverage_fout);
      ___coverage_array[3867] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3884] == 0) {
    {
    fprintf(_coverage_fout, "3884\n");
    fflush(_coverage_fout);
    ___coverage_array[3884] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3869] == 0) {
      {
      fprintf(_coverage_fout, "3869\n");
      fflush(_coverage_fout);
      ___coverage_array[3869] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )*__s == (int )__sep) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3868] == 0) {
        {
        fprintf(_coverage_fout, "3868\n");
        fflush(_coverage_fout);
        ___coverage_array[3868] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3870] == 0) {
      {
      fprintf(_coverage_fout, "3870\n");
      fflush(_coverage_fout);
      ___coverage_array[3870] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3885] == 0) {
    {
    fprintf(_coverage_fout, "3885\n");
    fflush(_coverage_fout);
    ___coverage_array[3885] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3886] == 0) {
    {
    fprintf(_coverage_fout, "3886\n");
    fflush(_coverage_fout);
    ___coverage_array[3886] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )*__s != 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3878] == 0) {
      {
      fprintf(_coverage_fout, "3878\n");
      fflush(_coverage_fout);
      ___coverage_array[3878] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = __s;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3879] == 0) {
      {
      fprintf(_coverage_fout, "3879\n");
      fflush(_coverage_fout);
      ___coverage_array[3879] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3880] == 0) {
      {
      fprintf(_coverage_fout, "3880\n");
      fflush(_coverage_fout);
      ___coverage_array[3880] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result = tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3881] == 0) {
      {
      fprintf(_coverage_fout, "3881\n");
      fflush(_coverage_fout);
      ___coverage_array[3881] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3874] == 0) {
        {
        fprintf(_coverage_fout, "3874\n");
        fflush(_coverage_fout);
        ___coverage_array[3874] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__s != 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3871] == 0) {
          {
          fprintf(_coverage_fout, "3871\n");
          fflush(_coverage_fout);
          ___coverage_array[3871] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3875] == 0) {
        {
        fprintf(_coverage_fout, "3875\n");
        fflush(_coverage_fout);
        ___coverage_array[3875] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = __s;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3876] == 0) {
        {
        fprintf(_coverage_fout, "3876\n");
        fflush(_coverage_fout);
        ___coverage_array[3876] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s ++;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3877] == 0) {
        {
        fprintf(_coverage_fout, "3877\n");
        fflush(_coverage_fout);
        ___coverage_array[3877] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*tmp___0 == (int )__sep) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3872] == 0) {
          {
          fprintf(_coverage_fout, "3872\n");
          fflush(_coverage_fout);
          ___coverage_array[3872] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *(__s + -1) = (char )'\000';
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3873] == 0) {
          {
          fprintf(_coverage_fout, "3873\n");
          fflush(_coverage_fout);
          ___coverage_array[3873] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3882] == 0) {
      {
      fprintf(_coverage_fout, "3882\n");
      fflush(_coverage_fout);
      ___coverage_array[3882] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3887] == 0) {
    {
    fprintf(_coverage_fout, "3887\n");
    fflush(_coverage_fout);
    ___coverage_array[3887] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *__nextp = __s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3888] == 0) {
    {
    fprintf(_coverage_fout, "3888\n");
    fflush(_coverage_fout);
    ___coverage_array[3888] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__result);
}
}
extern char *__strsep_g(char **__stringp , char const   *__delim ) ;
__inline extern char *__strsep_1c(char **__s , char __reject ) ;
__inline extern char *__strsep_1c(char **__s , char __reject ) 
{ register char *__retval ;
  char *tmp ;
  char *tmp___0 ;
  void *tmp___1 ;
  char *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3898] == 0) {
    {
    fprintf(_coverage_fout, "3898\n");
    fflush(_coverage_fout);
    ___coverage_array[3898] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __retval = *__s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3899] == 0) {
    {
    fprintf(_coverage_fout, "3899\n");
    fflush(_coverage_fout);
    ___coverage_array[3899] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3893] == 0) {
      {
      fprintf(_coverage_fout, "3893\n");
      fflush(_coverage_fout);
      ___coverage_array[3893] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = __builtin_strchr(__retval, (int )__reject);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3894] == 0) {
      {
      fprintf(_coverage_fout, "3894\n");
      fflush(_coverage_fout);
      ___coverage_array[3894] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3895] == 0) {
      {
      fprintf(_coverage_fout, "3895\n");
      fflush(_coverage_fout);
      ___coverage_array[3895] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__s = tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3896] == 0) {
      {
      fprintf(_coverage_fout, "3896\n");
      fflush(_coverage_fout);
      ___coverage_array[3896] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )tmp___0 != (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3889] == 0) {
        {
        fprintf(_coverage_fout, "3889\n");
        fflush(_coverage_fout);
        ___coverage_array[3889] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = *__s;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3890] == 0) {
        {
        fprintf(_coverage_fout, "3890\n");
        fflush(_coverage_fout);
        ___coverage_array[3890] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (*__s) ++;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3891] == 0) {
        {
        fprintf(_coverage_fout, "3891\n");
        fflush(_coverage_fout);
        ___coverage_array[3891] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *tmp = (char )'\000';
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3892] == 0) {
        {
        fprintf(_coverage_fout, "3892\n");
        fflush(_coverage_fout);
        ___coverage_array[3892] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3897] == 0) {
      {
      fprintf(_coverage_fout, "3897\n");
      fflush(_coverage_fout);
      ___coverage_array[3897] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3900] == 0) {
    {
    fprintf(_coverage_fout, "3900\n");
    fflush(_coverage_fout);
    ___coverage_array[3900] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__retval);
}
}
__inline extern char *__strsep_2c(char **__s , char __reject1 , char __reject2 ) ;
__inline extern char *__strsep_2c(char **__s , char __reject1 , char __reject2 ) 
{ register char *__retval ;
  register char *__cp ;
  char *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3918] == 0) {
    {
    fprintf(_coverage_fout, "3918\n");
    fflush(_coverage_fout);
    ___coverage_array[3918] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __retval = *__s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3919] == 0) {
    {
    fprintf(_coverage_fout, "3919\n");
    fflush(_coverage_fout);
    ___coverage_array[3919] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3914] == 0) {
      {
      fprintf(_coverage_fout, "3914\n");
      fflush(_coverage_fout);
      ___coverage_array[3914] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __cp = __retval;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3915] == 0) {
      {
      fprintf(_coverage_fout, "3915\n");
      fflush(_coverage_fout);
      ___coverage_array[3915] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3911] == 0) {
        {
        fprintf(_coverage_fout, "3911\n");
        fflush(_coverage_fout);
        ___coverage_array[3911] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3901] == 0) {
          {
          fprintf(_coverage_fout, "3901\n");
          fflush(_coverage_fout);
          ___coverage_array[3901] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3902] == 0) {
          {
          fprintf(_coverage_fout, "3902\n");
          fflush(_coverage_fout);
          ___coverage_array[3902] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3912] == 0) {
        {
        fprintf(_coverage_fout, "3912\n");
        fflush(_coverage_fout);
        ___coverage_array[3912] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3903] == 0) {
          {
          fprintf(_coverage_fout, "3903\n");
          fflush(_coverage_fout);
          ___coverage_array[3903] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __cp;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3904] == 0) {
          {
          fprintf(_coverage_fout, "3904\n");
          fflush(_coverage_fout);
          ___coverage_array[3904] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3905] == 0) {
          {
          fprintf(_coverage_fout, "3905\n");
          fflush(_coverage_fout);
          ___coverage_array[3905] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3910] == 0) {
          {
          fprintf(_coverage_fout, "3910\n");
          fflush(_coverage_fout);
          ___coverage_array[3910] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3906] == 0) {
            {
            fprintf(_coverage_fout, "3906\n");
            fflush(_coverage_fout);
            ___coverage_array[3906] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp = __cp;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3907] == 0) {
            {
            fprintf(_coverage_fout, "3907\n");
            fflush(_coverage_fout);
            ___coverage_array[3907] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __cp ++;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3908] == 0) {
            {
            fprintf(_coverage_fout, "3908\n");
            fflush(_coverage_fout);
            ___coverage_array[3908] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3909] == 0) {
            {
            fprintf(_coverage_fout, "3909\n");
            fflush(_coverage_fout);
            ___coverage_array[3909] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3913] == 0) {
        {
        fprintf(_coverage_fout, "3913\n");
        fflush(_coverage_fout);
        ___coverage_array[3913] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __cp ++;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3916] == 0) {
      {
      fprintf(_coverage_fout, "3916\n");
      fflush(_coverage_fout);
      ___coverage_array[3916] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3917] == 0) {
      {
      fprintf(_coverage_fout, "3917\n");
      fflush(_coverage_fout);
      ___coverage_array[3917] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3920] == 0) {
    {
    fprintf(_coverage_fout, "3920\n");
    fflush(_coverage_fout);
    ___coverage_array[3920] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__retval);
}
}
__inline extern char *__strsep_3c(char **__s , char __reject1 , char __reject2 ,
                                  char __reject3 ) ;
__inline extern char *__strsep_3c(char **__s , char __reject1 , char __reject2 ,
                                  char __reject3 ) 
{ register char *__retval ;
  register char *__cp ;
  char *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3942] == 0) {
    {
    fprintf(_coverage_fout, "3942\n");
    fflush(_coverage_fout);
    ___coverage_array[3942] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __retval = *__s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3943] == 0) {
    {
    fprintf(_coverage_fout, "3943\n");
    fflush(_coverage_fout);
    ___coverage_array[3943] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3938] == 0) {
      {
      fprintf(_coverage_fout, "3938\n");
      fflush(_coverage_fout);
      ___coverage_array[3938] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __cp = __retval;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3939] == 0) {
      {
      fprintf(_coverage_fout, "3939\n");
      fflush(_coverage_fout);
      ___coverage_array[3939] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3935] == 0) {
        {
        fprintf(_coverage_fout, "3935\n");
        fflush(_coverage_fout);
        ___coverage_array[3935] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3921] == 0) {
          {
          fprintf(_coverage_fout, "3921\n");
          fflush(_coverage_fout);
          ___coverage_array[3921] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3922] == 0) {
          {
          fprintf(_coverage_fout, "3922\n");
          fflush(_coverage_fout);
          ___coverage_array[3922] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3936] == 0) {
        {
        fprintf(_coverage_fout, "3936\n");
        fflush(_coverage_fout);
        ___coverage_array[3936] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3923] == 0) {
          {
          fprintf(_coverage_fout, "3923\n");
          fflush(_coverage_fout);
          ___coverage_array[3923] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __cp;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3924] == 0) {
          {
          fprintf(_coverage_fout, "3924\n");
          fflush(_coverage_fout);
          ___coverage_array[3924] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3925] == 0) {
          {
          fprintf(_coverage_fout, "3925\n");
          fflush(_coverage_fout);
          ___coverage_array[3925] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[3934] == 0) {
          {
          fprintf(_coverage_fout, "3934\n");
          fflush(_coverage_fout);
          ___coverage_array[3934] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3926] == 0) {
            {
            fprintf(_coverage_fout, "3926\n");
            fflush(_coverage_fout);
            ___coverage_array[3926] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp = __cp;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3927] == 0) {
            {
            fprintf(_coverage_fout, "3927\n");
            fflush(_coverage_fout);
            ___coverage_array[3927] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __cp ++;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3928] == 0) {
            {
            fprintf(_coverage_fout, "3928\n");
            fflush(_coverage_fout);
            ___coverage_array[3928] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[3933] == 0) {
            {
            fprintf(_coverage_fout, "3933\n");
            fflush(_coverage_fout);
            ___coverage_array[3933] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int )*__cp == (int )__reject3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3929] == 0) {
              {
              fprintf(_coverage_fout, "3929\n");
              fflush(_coverage_fout);
              ___coverage_array[3929] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp = __cp;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3930] == 0) {
              {
              fprintf(_coverage_fout, "3930\n");
              fflush(_coverage_fout);
              ___coverage_array[3930] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __cp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3931] == 0) {
              {
              fprintf(_coverage_fout, "3931\n");
              fflush(_coverage_fout);
              ___coverage_array[3931] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *tmp = (char )'\000';
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3932] == 0) {
              {
              fprintf(_coverage_fout, "3932\n");
              fflush(_coverage_fout);
              ___coverage_array[3932] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3937] == 0) {
        {
        fprintf(_coverage_fout, "3937\n");
        fflush(_coverage_fout);
        ___coverage_array[3937] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __cp ++;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3940] == 0) {
      {
      fprintf(_coverage_fout, "3940\n");
      fflush(_coverage_fout);
      ___coverage_array[3940] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3941] == 0) {
      {
      fprintf(_coverage_fout, "3941\n");
      fflush(_coverage_fout);
      ___coverage_array[3941] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3944] == 0) {
    {
    fprintf(_coverage_fout, "3944\n");
    fflush(_coverage_fout);
    ___coverage_array[3944] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__retval);
}
}
extern  __attribute__((__nothrow__)) char *__strdup(char const   *__string )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) char *__strndup(char const   *__string ,
                                                     size_t __n )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) double acos(double __x ) ;
extern  __attribute__((__nothrow__)) double __acos(double __x ) ;
extern  __attribute__((__nothrow__)) double asin(double __x ) ;
extern  __attribute__((__nothrow__)) double __asin(double __x ) ;
extern  __attribute__((__nothrow__)) double atan(double __x ) ;
extern  __attribute__((__nothrow__)) double __atan(double __x ) ;
extern  __attribute__((__nothrow__)) double atan2(double __y , double __x ) ;
extern  __attribute__((__nothrow__)) double __atan2(double __y , double __x ) ;
extern  __attribute__((__nothrow__)) double cos(double __x ) ;
extern  __attribute__((__nothrow__)) double __cos(double __x ) ;
extern  __attribute__((__nothrow__)) double sin(double __x ) ;
extern  __attribute__((__nothrow__)) double __sin(double __x ) ;
extern  __attribute__((__nothrow__)) double tan(double __x ) ;
extern  __attribute__((__nothrow__)) double __tan(double __x ) ;
extern  __attribute__((__nothrow__)) double cosh(double __x ) ;
extern  __attribute__((__nothrow__)) double __cosh(double __x ) ;
extern  __attribute__((__nothrow__)) double sinh(double __x ) ;
extern  __attribute__((__nothrow__)) double __sinh(double __x ) ;
extern  __attribute__((__nothrow__)) double tanh(double __x ) ;
extern  __attribute__((__nothrow__)) double __tanh(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 acosh(double __x ) ;
extern  __attribute__((__nothrow__)) double __acosh(double __x ) ;
extern  __attribute__((__nothrow__)) double asinh(double __x ) ;
extern  __attribute__((__nothrow__)) double __asinh(double __x ) ;
extern  __attribute__((__nothrow__)) double atanh(double __x ) ;
extern  __attribute__((__nothrow__)) double __atanh(double __x ) ;
extern  __attribute__((__nothrow__)) double exp(double __x ) ;
extern  __attribute__((__nothrow__)) double __exp(double __x ) ;
extern  __attribute__((__nothrow__)) double frexp(double __x , int *__exponent ) ;
extern  __attribute__((__nothrow__)) double __frexp(double __x ,
                                                    int *__exponent ) ;
extern  __attribute__((__nothrow__)) double ldexp(double __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) double __ldexp(double __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) double log(double __x ) ;
extern  __attribute__((__nothrow__)) double __log(double __x ) ;
extern  __attribute__((__nothrow__)) double log10(double __x ) ;
extern  __attribute__((__nothrow__)) double __log10(double __x ) ;
extern  __attribute__((__nothrow__)) double modf(double __x , double *__iptr ) ;
extern  __attribute__((__nothrow__)) double __modf(double __x , double *__iptr ) ;
extern  __attribute__((__nothrow__)) double exp10(double __x ) ;
extern  __attribute__((__nothrow__)) double __exp10(double __x ) ;
extern  __attribute__((__nothrow__)) double pow10(double __x ) ;
extern  __attribute__((__nothrow__)) double __pow10(double __x ) ;
extern  __attribute__((__nothrow__)) double expm1(double __x ) ;
extern  __attribute__((__nothrow__)) double __expm1(double __x ) ;
extern  __attribute__((__nothrow__)) double log1p(double __x ) ;
extern  __attribute__((__nothrow__)) double __log1p(double __x ) ;
extern  __attribute__((__nothrow__)) double logb(double __x ) ;
extern  __attribute__((__nothrow__)) double __logb(double __x ) ;
extern  __attribute__((__nothrow__)) double exp2(double __x ) ;
extern  __attribute__((__nothrow__)) double __exp2(double __x ) ;
extern  __attribute__((__nothrow__)) double log2(double __x ) ;
extern  __attribute__((__nothrow__)) double __log2(double __x ) ;
extern  __attribute__((__nothrow__)) double pow(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __pow(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double sqrt(double __x ) ;
extern  __attribute__((__nothrow__)) double __sqrt(double __x ) ;
extern  __attribute__((__nothrow__)) double hypot(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __hypot(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double cbrt(double __x ) ;
extern  __attribute__((__nothrow__)) double __cbrt(double __x ) ;
__inline extern  __attribute__((__nothrow__)) double ceil(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __ceil(double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) double fabs(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __fabs(double __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) double floor(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __floor(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double fmod(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __fmod(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) int __isinf(double __value )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) int __finite(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isinf(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int finite(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double drem(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __drem(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double significand(double __x ) ;
extern  __attribute__((__nothrow__)) double __significand(double __x ) ;
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 nan(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __nan(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isnan(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isnan(double __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double j0(double  ) ;
extern  __attribute__((__nothrow__)) double __j0(double  ) ;
extern  __attribute__((__nothrow__)) double j1(double  ) ;
extern  __attribute__((__nothrow__)) double __j1(double  ) ;
extern  __attribute__((__nothrow__)) double jn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double __jn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double y0(double  ) ;
extern  __attribute__((__nothrow__)) double __y0(double  ) ;
extern  __attribute__((__nothrow__)) double y1(double  ) ;
extern  __attribute__((__nothrow__)) double __y1(double  ) ;
extern  __attribute__((__nothrow__)) double yn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double __yn(int  , double  ) ;
extern  __attribute__((__nothrow__)) double erf(double  ) ;
extern  __attribute__((__nothrow__)) double __erf(double  ) ;
extern  __attribute__((__nothrow__)) double erfc(double  ) ;
extern  __attribute__((__nothrow__)) double __erfc(double  ) ;
extern  __attribute__((__nothrow__)) double lgamma(double  ) ;
extern  __attribute__((__nothrow__)) double __lgamma(double  ) ;
extern  __attribute__((__nothrow__)) double tgamma(double  ) ;
extern  __attribute__((__nothrow__)) double __tgamma(double  ) ;
extern  __attribute__((__nothrow__)) double gamma(double  ) ;
extern  __attribute__((__nothrow__)) double __gamma(double  ) ;
extern  __attribute__((__nothrow__)) double lgamma_r(double  , int *__signgamp ) ;
extern  __attribute__((__nothrow__)) double __lgamma_r(double  ,
                                                       int *__signgamp ) ;
extern  __attribute__((__nothrow__)) double rint(double __x ) ;
extern  __attribute__((__nothrow__)) double __rint(double __x ) ;
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 nexttoward(double __x ,
                                                       long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __nexttoward(double __x ,
                                                         long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double remainder(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __remainder(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double scalbn(double __x , int __n ) ;
extern  __attribute__((__nothrow__)) double __scalbn(double __x , int __n ) ;
extern  __attribute__((__nothrow__)) int ilogb(double __x ) ;
extern  __attribute__((__nothrow__)) int __ilogb(double __x ) ;
extern  __attribute__((__nothrow__)) double scalbln(double __x , long __n ) ;
extern  __attribute__((__nothrow__)) double __scalbln(double __x , long __n ) ;
extern  __attribute__((__nothrow__)) double nearbyint(double __x ) ;
extern  __attribute__((__nothrow__)) double __nearbyint(double __x ) ;
extern  __attribute__((__nothrow__)) double round(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __round(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double trunc(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double __trunc(double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) double remquo(double __x , double __y ,
                                                   int *__quo ) ;
extern  __attribute__((__nothrow__)) double __remquo(double __x , double __y ,
                                                     int *__quo ) ;
__inline extern  __attribute__((__nothrow__)) long lrint(double __x ) ;
extern  __attribute__((__nothrow__)) long __lrint(double __x ) ;
__inline extern  __attribute__((__nothrow__)) long long llrint(double __x ) ;
extern  __attribute__((__nothrow__)) long long __llrint(double __x ) ;
extern  __attribute__((__nothrow__)) long lround(double __x ) ;
extern  __attribute__((__nothrow__)) long __lround(double __x ) ;
extern  __attribute__((__nothrow__)) long long llround(double __x ) ;
extern  __attribute__((__nothrow__)) long long __llround(double __x ) ;
extern  __attribute__((__nothrow__)) double fdim(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __fdim(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 fmin(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) double __fmin(double __x , double __y ) ;
extern  __attribute__((__nothrow__)) int __fpclassify(double __value )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) int __signbit(double __x )  __attribute__((__const__)) ;
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__)) double scalb(double __x , double __n ) ;
extern  __attribute__((__nothrow__)) double __scalb(double __x , double __n ) ;
extern  __attribute__((__nothrow__)) float acosf(float __x ) ;
extern  __attribute__((__nothrow__)) float __acosf(float __x ) ;
extern  __attribute__((__nothrow__)) float asinf(float __x ) ;
extern  __attribute__((__nothrow__)) float __asinf(float __x ) ;
extern  __attribute__((__nothrow__)) float atanf(float __x ) ;
extern  __attribute__((__nothrow__)) float __atanf(float __x ) ;
extern  __attribute__((__nothrow__)) float atan2f(float __y , float __x ) ;
extern  __attribute__((__nothrow__)) float __atan2f(float __y , float __x ) ;
extern  __attribute__((__nothrow__)) float cosf(float __x ) ;
extern  __attribute__((__nothrow__)) float __cosf(float __x ) ;
extern  __attribute__((__nothrow__)) float sinf(float __x ) ;
extern  __attribute__((__nothrow__)) float __sinf(float __x ) ;
extern  __attribute__((__nothrow__)) float tanf(float __x ) ;
extern  __attribute__((__nothrow__)) float __tanf(float __x ) ;
extern  __attribute__((__nothrow__)) float coshf(float __x ) ;
extern  __attribute__((__nothrow__)) float __coshf(float __x ) ;
extern  __attribute__((__nothrow__)) float sinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __sinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float tanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __tanhf(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 acoshf(float __x ) ;
extern  __attribute__((__nothrow__)) float __acoshf(float __x ) ;
extern  __attribute__((__nothrow__)) float asinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __asinhf(float __x ) ;
extern  __attribute__((__nothrow__)) float atanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float __atanhf(float __x ) ;
extern  __attribute__((__nothrow__)) float expf(float __x ) ;
extern  __attribute__((__nothrow__)) float __expf(float __x ) ;
extern  __attribute__((__nothrow__)) float frexpf(float __x , int *__exponent ) ;
extern  __attribute__((__nothrow__)) float __frexpf(float __x , int *__exponent ) ;
extern  __attribute__((__nothrow__)) float ldexpf(float __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) float __ldexpf(float __x , int __exponent ) ;
extern  __attribute__((__nothrow__)) float logf(float __x ) ;
extern  __attribute__((__nothrow__)) float __logf(float __x ) ;
extern  __attribute__((__nothrow__)) float log10f(float __x ) ;
extern  __attribute__((__nothrow__)) float __log10f(float __x ) ;
extern  __attribute__((__nothrow__)) float modff(float __x , float *__iptr ) ;
extern  __attribute__((__nothrow__)) float __modff(float __x , float *__iptr ) ;
extern  __attribute__((__nothrow__)) float exp10f(float __x ) ;
extern  __attribute__((__nothrow__)) float __exp10f(float __x ) ;
extern  __attribute__((__nothrow__)) float pow10f(float __x ) ;
extern  __attribute__((__nothrow__)) float __pow10f(float __x ) ;
extern  __attribute__((__nothrow__)) float expm1f(float __x ) ;
extern  __attribute__((__nothrow__)) float __expm1f(float __x ) ;
extern  __attribute__((__nothrow__)) float log1pf(float __x ) ;
extern  __attribute__((__nothrow__)) float __log1pf(float __x ) ;
extern  __attribute__((__nothrow__)) float logbf(float __x ) ;
extern  __attribute__((__nothrow__)) float __logbf(float __x ) ;
extern  __attribute__((__nothrow__)) float exp2f(float __x ) ;
extern  __attribute__((__nothrow__)) float __exp2f(float __x ) ;
extern  __attribute__((__nothrow__)) float log2f(float __x ) ;
extern  __attribute__((__nothrow__)) float __log2f(float __x ) ;
extern  __attribute__((__nothrow__)) float powf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __powf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float sqrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float __sqrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float hypotf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __hypotf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float cbrtf(float __x ) ;
extern  __attribute__((__nothrow__)) float __cbrtf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) float ceilf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __ceilf(float __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) float fabsf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __fabsf(float __x )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) float floorf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __floorf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float fmodf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __fmodf(float __x , float __y ) ;
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__)) int finitef(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float dremf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __dremf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float significandf(float __x ) ;
extern  __attribute__((__nothrow__)) float __significandf(float __x ) ;
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 nanf(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __nanf(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int __isnanf(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isnanf(float __value )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float j0f(float  ) ;
extern  __attribute__((__nothrow__)) float __j0f(float  ) ;
extern  __attribute__((__nothrow__)) float j1f(float  ) ;
extern  __attribute__((__nothrow__)) float __j1f(float  ) ;
extern  __attribute__((__nothrow__)) float jnf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float __jnf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float y0f(float  ) ;
extern  __attribute__((__nothrow__)) float __y0f(float  ) ;
extern  __attribute__((__nothrow__)) float y1f(float  ) ;
extern  __attribute__((__nothrow__)) float __y1f(float  ) ;
extern  __attribute__((__nothrow__)) float ynf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float __ynf(int  , float  ) ;
extern  __attribute__((__nothrow__)) float erff(float  ) ;
extern  __attribute__((__nothrow__)) float __erff(float  ) ;
extern  __attribute__((__nothrow__)) float erfcf(float  ) ;
extern  __attribute__((__nothrow__)) float __erfcf(float  ) ;
extern  __attribute__((__nothrow__)) float lgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float __lgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float tgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float __tgammaf(float  ) ;
extern  __attribute__((__nothrow__)) float gammaf(float  ) ;
extern  __attribute__((__nothrow__)) float __gammaf(float  ) ;
extern  __attribute__((__nothrow__)) float lgammaf_r(float  , int *__signgamp ) ;
extern  __attribute__((__nothrow__)) float __lgammaf_r(float  , int *__signgamp ) ;
extern  __attribute__((__nothrow__)) float rintf(float __x ) ;
extern  __attribute__((__nothrow__)) float __rintf(float __x ) ;
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 nexttowardf(float __x ,
                                                       long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __nexttowardf(float __x ,
                                                         long double __y )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float remainderf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __remainderf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float scalbnf(float __x , int __n ) ;
extern  __attribute__((__nothrow__)) float __scalbnf(float __x , int __n ) ;
extern  __attribute__((__nothrow__)) int ilogbf(float __x ) ;
extern  __attribute__((__nothrow__)) int __ilogbf(float __x ) ;
extern  __attribute__((__nothrow__)) float scalblnf(float __x , long __n ) ;
extern  __attribute__((__nothrow__)) float __scalblnf(float __x , long __n ) ;
extern  __attribute__((__nothrow__)) float nearbyintf(float __x ) ;
extern  __attribute__((__nothrow__)) float __nearbyintf(float __x ) ;
extern  __attribute__((__nothrow__)) float roundf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __roundf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float truncf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float __truncf(float __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) float remquof(float __x , float __y ,
                                                   int *__quo ) ;
extern  __attribute__((__nothrow__)) float __remquof(float __x , float __y ,
                                                     int *__quo ) ;
__inline extern  __attribute__((__nothrow__)) long lrintf(float __x ) ;
extern  __attribute__((__nothrow__)) long __lrintf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) long long llrintf(float __x ) ;
extern  __attribute__((__nothrow__)) long long __llrintf(float __x ) ;
extern  __attribute__((__nothrow__)) long lroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long __lroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long long llroundf(float __x ) ;
extern  __attribute__((__nothrow__)) long long __llroundf(float __x ) ;
extern  __attribute__((__nothrow__)) float fdimf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __fdimf(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 fminf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) float __fminf(float __x , float __y ) ;
extern  __attribute__((__nothrow__)) int __fpclassifyf(float __value )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) int __signbitf(float __x )  __attribute__((__const__)) ;
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__)) float scalbf(float __x , float __n ) ;
extern  __attribute__((__nothrow__)) float __scalbf(float __x , float __n ) ;
extern  __attribute__((__nothrow__)) long double acosl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __acosl(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 atanl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __atanl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double atan2l(long double __y ,
                                                        long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double __atan2l(long double __y ,
                                                                   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 sinl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __sinl(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 coshl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __coshl(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 tanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __tanhl(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 acoshl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __acoshl(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 atanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __atanhl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double expl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __expl(long double __x ) ;
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 ldexpl(long double __x ,
                                                        int __exponent ) ;
extern  __attribute__((__nothrow__)) long double __ldexpl(long double __x ,
                                                          int __exponent ) ;
extern  __attribute__((__nothrow__)) long double logl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __logl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double log10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __log10l(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 exp10l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __exp10l(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 expm1l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __expm1l(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 logbl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __logbl(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 log2l(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __log2l(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 sqrtl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __sqrtl(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 cbrtl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __cbrtl(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double ceill(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __ceill(long double __x )  __attribute__((__const__)) ;
__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  __attribute__((__nothrow__)) long double floorl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __floorl(long double __x )  __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__)) 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__)) int finitel(long double __value )  __attribute__((__const__)) ;
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__)) long double significandl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __significandl(long double __x ) ;
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 nanl(char const   *__tagb )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __nanl(char const   *__tagb )  __attribute__((__const__)) ;
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 j0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __j0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double j1l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __j1l(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 y0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __y0l(long double  ) ;
extern  __attribute__((__nothrow__)) long double y1l(long double  ) ;
extern  __attribute__((__nothrow__)) long double __y1l(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 erfl(long double  ) ;
extern  __attribute__((__nothrow__)) long double __erfl(long double  ) ;
extern  __attribute__((__nothrow__)) long double erfcl(long double  ) ;
extern  __attribute__((__nothrow__)) long double __erfcl(long double  ) ;
extern  __attribute__((__nothrow__)) long double lgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double __lgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double tgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double __tgammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double gammal(long double  ) ;
extern  __attribute__((__nothrow__)) long double __gammal(long double  ) ;
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 rintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __rintl(long double __x ) ;
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 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 remainderl(long double __x ,
                                                            long double __y ) ;
extern  __attribute__((__nothrow__)) long double __remainderl(long double __x ,
                                                              long double __y ) ;
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__)) int ilogbl(long double __x ) ;
extern  __attribute__((__nothrow__)) int __ilogbl(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__)) long double nearbyintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long double __nearbyintl(long double __x ) ;
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 truncl(long double __x )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) long double __truncl(long double __x )  __attribute__((__const__)) ;
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 ) ;
__inline extern  __attribute__((__nothrow__)) long lrintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long __lrintl(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long long llrintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long long __llrintl(long double __x ) ;
extern  __attribute__((__nothrow__)) long lroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long __lroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long long llroundl(long double __x ) ;
extern  __attribute__((__nothrow__)) long long __llroundl(long double __x ) ;
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 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 fminl(long double __x ,
                                                       long double __y ) ;
extern  __attribute__((__nothrow__)) long double __fminl(long double __x ,
                                                         long double __y ) ;
extern  __attribute__((__nothrow__)) int __fpclassifyl(long double __value )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) int __signbitl(long double __x )  __attribute__((__const__)) ;
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__)) long double scalbl(long double __x ,
                                                        long double __n ) ;
extern  __attribute__((__nothrow__)) long double __scalbl(long double __x ,
                                                          long double __n ) ;
extern int signgam ;
extern _LIB_VERSION_TYPE _LIB_VERSION ;
extern int matherr(struct exception *__exc ) ;
__inline extern  __attribute__((__nothrow__)) int __signbitf(float __x )  __attribute__((__const__)) ;
__inline extern int __signbitf(float __x ) 
{ union __anonunion___u_24 __u ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3945] == 0) {
    {
    fprintf(_coverage_fout, "3945\n");
    fflush(_coverage_fout);
    ___coverage_array[3945] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __u.__f = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3946] == 0) {
    {
    fprintf(_coverage_fout, "3946\n");
    fflush(_coverage_fout);
    ___coverage_array[3946] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__u.__i < 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbit(double __x )  __attribute__((__const__)) ;
__inline extern int __signbit(double __x ) 
{ union __anonunion___u_25 __u ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3947] == 0) {
    {
    fprintf(_coverage_fout, "3947\n");
    fflush(_coverage_fout);
    ___coverage_array[3947] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __u.__d = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3948] == 0) {
    {
    fprintf(_coverage_fout, "3948\n");
    fflush(_coverage_fout);
    ___coverage_array[3948] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__u.__i[1] < 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbitl(long double __x )  __attribute__((__const__)) ;
__inline extern int __signbitl(long double __x ) 
{ union __anonunion___u_26 __u ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3949] == 0) {
    {
    fprintf(_coverage_fout, "3949\n");
    fflush(_coverage_fout);
    ___coverage_array[3949] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __u.__l = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3950] == 0) {
    {
    fprintf(_coverage_fout, "3950\n");
    fflush(_coverage_fout);
    ___coverage_array[3950] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((__u.__i[2] & 0x8000) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) double __sgn(double __x ) ;
__inline extern  __attribute__((__nothrow__)) double __sgn(double __x ) ;
__inline extern double __sgn(double __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3956] == 0) {
    {
    fprintf(_coverage_fout, "3956\n");
    fflush(_coverage_fout);
    ___coverage_array[3956] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__x == 0.0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3951] == 0) {
      {
      fprintf(_coverage_fout, "3951\n");
      fflush(_coverage_fout);
      ___coverage_array[3951] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3954] == 0) {
      {
      fprintf(_coverage_fout, "3954\n");
      fflush(_coverage_fout);
      ___coverage_array[3954] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (__x > 0.0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3952] == 0) {
        {
        fprintf(_coverage_fout, "3952\n");
        fflush(_coverage_fout);
        ___coverage_array[3952] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3953] == 0) {
        {
        fprintf(_coverage_fout, "3953\n");
        fflush(_coverage_fout);
        ___coverage_array[3953] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3955] == 0) {
      {
      fprintf(_coverage_fout, "3955\n");
      fflush(_coverage_fout);
      ___coverage_array[3955] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3957] == 0) {
    {
    fprintf(_coverage_fout, "3957\n");
    fflush(_coverage_fout);
    ___coverage_array[3957] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) float __sgnf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) float __sgnf(float __x ) ;
__inline extern float __sgnf(float __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3963] == 0) {
    {
    fprintf(_coverage_fout, "3963\n");
    fflush(_coverage_fout);
    ___coverage_array[3963] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((double )__x == 0.0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3958] == 0) {
      {
      fprintf(_coverage_fout, "3958\n");
      fflush(_coverage_fout);
      ___coverage_array[3958] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3961] == 0) {
      {
      fprintf(_coverage_fout, "3961\n");
      fflush(_coverage_fout);
      ___coverage_array[3961] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((double )__x > 0.0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3959] == 0) {
        {
        fprintf(_coverage_fout, "3959\n");
        fflush(_coverage_fout);
        ___coverage_array[3959] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3960] == 0) {
        {
        fprintf(_coverage_fout, "3960\n");
        fflush(_coverage_fout);
        ___coverage_array[3960] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3962] == 0) {
      {
      fprintf(_coverage_fout, "3962\n");
      fflush(_coverage_fout);
      ___coverage_array[3962] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3964] == 0) {
    {
    fprintf(_coverage_fout, "3964\n");
    fflush(_coverage_fout);
    ___coverage_array[3964] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((float )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) long double __sgnl(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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3970] == 0) {
    {
    fprintf(_coverage_fout, "3970\n");
    fflush(_coverage_fout);
    ___coverage_array[3970] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__x == (long double )0.0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3965] == 0) {
      {
      fprintf(_coverage_fout, "3965\n");
      fflush(_coverage_fout);
      ___coverage_array[3965] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3968] == 0) {
      {
      fprintf(_coverage_fout, "3968\n");
      fflush(_coverage_fout);
      ___coverage_array[3968] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (__x > (long double )0.0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3966] == 0) {
        {
        fprintf(_coverage_fout, "3966\n");
        fflush(_coverage_fout);
        ___coverage_array[3966] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[3967] == 0) {
        {
        fprintf(_coverage_fout, "3967\n");
        fflush(_coverage_fout);
        ___coverage_array[3967] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[3969] == 0) {
      {
      fprintf(_coverage_fout, "3969\n");
      fflush(_coverage_fout);
      ___coverage_array[3969] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3971] == 0) {
    {
    fprintf(_coverage_fout, "3971\n");
    fflush(_coverage_fout);
    ___coverage_array[3971] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((long double )tmp___0);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3972] == 0) {
    {
    fprintf(_coverage_fout, "3972\n");
    fflush(_coverage_fout);
    ___coverage_array[3972] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_atan2l(__y, __x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3973] == 0) {
    {
    fprintf(_coverage_fout, "3973\n");
    fflush(_coverage_fout);
    ___coverage_array[3973] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) double fabs(double __x )  __attribute__((__const__)) ;
__inline extern double fabs(double __x ) 
{ double tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3974] == 0) {
    {
    fprintf(_coverage_fout, "3974\n");
    fflush(_coverage_fout);
    ___coverage_array[3974] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabs(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3975] == 0) {
    {
    fprintf(_coverage_fout, "3975\n");
    fflush(_coverage_fout);
    ___coverage_array[3975] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) float fabsf(float __x )  __attribute__((__const__)) ;
__inline extern float fabsf(float __x ) 
{ float tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3976] == 0) {
    {
    fprintf(_coverage_fout, "3976\n");
    fflush(_coverage_fout);
    ___coverage_array[3976] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabsf(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3977] == 0) {
    {
    fprintf(_coverage_fout, "3977\n");
    fflush(_coverage_fout);
    ___coverage_array[3977] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern long double fabsl(long double __x ) 
{ long double tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3978] == 0) {
    {
    fprintf(_coverage_fout, "3978\n");
    fflush(_coverage_fout);
    ___coverage_array[3978] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3979] == 0) {
    {
    fprintf(_coverage_fout, "3979\n");
    fflush(_coverage_fout);
    ___coverage_array[3979] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double __fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern long double __fabsl(long double __x ) 
{ long double tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3980] == 0) {
    {
    fprintf(_coverage_fout, "3980\n");
    fflush(_coverage_fout);
    ___coverage_array[3980] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3981] == 0) {
    {
    fprintf(_coverage_fout, "3981\n");
    fflush(_coverage_fout);
    ___coverage_array[3981] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double __sgn1l(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double __sgn1l(long double __x ) ;
__inline extern long double __sgn1l(long double __x ) 
{ union __anonunion___n_27 __n ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3982] == 0) {
    {
    fprintf(_coverage_fout, "3982\n");
    fflush(_coverage_fout);
    ___coverage_array[3982] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xld = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3983] == 0) {
    {
    fprintf(_coverage_fout, "3983\n");
    fflush(_coverage_fout);
    ___coverage_array[3983] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xi[2] = (__n.__xi[2] & 32768U) | 16383U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3984] == 0) {
    {
    fprintf(_coverage_fout, "3984\n");
    fflush(_coverage_fout);
    ___coverage_array[3984] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xi[1] = 0x80000000;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3985] == 0) {
    {
    fprintf(_coverage_fout, "3985\n");
    fflush(_coverage_fout);
    ___coverage_array[3985] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xi[0] = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3986] == 0) {
    {
    fprintf(_coverage_fout, "3986\n");
    fflush(_coverage_fout);
    ___coverage_array[3986] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__n.__xld);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3987] == 0) {
    {
    fprintf(_coverage_fout, "3987\n");
    fflush(_coverage_fout);
    ___coverage_array[3987] = 1;
    }
  }
  fclose(_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));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3988] == 0) {
    {
    fprintf(_coverage_fout, "3988\n");
    fflush(_coverage_fout);
    ___coverage_array[3988] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((double )__value);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3989] == 0) {
    {
    fprintf(_coverage_fout, "3989\n");
    fflush(_coverage_fout);
    ___coverage_array[3989] = 1;
    }
  }
  fclose(_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));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3990] == 0) {
    {
    fprintf(_coverage_fout, "3990\n");
    fflush(_coverage_fout);
    ___coverage_array[3990] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((float )__value);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3991] == 0) {
    {
    fprintf(_coverage_fout, "3991\n");
    fflush(_coverage_fout);
    ___coverage_array[3991] = 1;
    }
  }
  fclose(_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));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3992] == 0) {
    {
    fprintf(_coverage_fout, "3992\n");
    fflush(_coverage_fout);
    ___coverage_array[3992] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__value);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3993] == 0) {
    {
    fprintf(_coverage_fout, "3993\n");
    fflush(_coverage_fout);
    ___coverage_array[3993] = 1;
    }
  }
  fclose(_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));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3994] == 0) {
    {
    fprintf(_coverage_fout, "3994\n");
    fflush(_coverage_fout);
    ___coverage_array[3994] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((double )__value);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3995] == 0) {
    {
    fprintf(_coverage_fout, "3995\n");
    fflush(_coverage_fout);
    ___coverage_array[3995] = 1;
    }
  }
  fclose(_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));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3996] == 0) {
    {
    fprintf(_coverage_fout, "3996\n");
    fflush(_coverage_fout);
    ___coverage_array[3996] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((float )__value);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3997] == 0) {
    {
    fprintf(_coverage_fout, "3997\n");
    fflush(_coverage_fout);
    ___coverage_array[3997] = 1;
    }
  }
  fclose(_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));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3998] == 0) {
    {
    fprintf(_coverage_fout, "3998\n");
    fflush(_coverage_fout);
    ___coverage_array[3998] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__value);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintf(float __x ) ;
__inline extern long lrintf(float __x ) 
{ long __lrintres ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[3999] == 0) {
    {
    fprintf(_coverage_fout, "3999\n");
    fflush(_coverage_fout);
    ___coverage_array[3999] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4000] == 0) {
    {
    fprintf(_coverage_fout, "4000\n");
    fflush(_coverage_fout);
    ___coverage_array[4000] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrint(double __x ) ;
__inline extern long lrint(double __x ) 
{ long __lrintres ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4001] == 0) {
    {
    fprintf(_coverage_fout, "4001\n");
    fflush(_coverage_fout);
    ___coverage_array[4001] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4002] == 0) {
    {
    fprintf(_coverage_fout, "4002\n");
    fflush(_coverage_fout);
    ___coverage_array[4002] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintl(long double __x ) ;
__inline extern long lrintl(long double __x ) 
{ long __lrintres ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4003] == 0) {
    {
    fprintf(_coverage_fout, "4003\n");
    fflush(_coverage_fout);
    ___coverage_array[4003] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4004] == 0) {
    {
    fprintf(_coverage_fout, "4004\n");
    fflush(_coverage_fout);
    ___coverage_array[4004] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintf(float __x ) ;
__inline extern long long llrintf(float __x ) 
{ long long __llrintres ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4005] == 0) {
    {
    fprintf(_coverage_fout, "4005\n");
    fflush(_coverage_fout);
    ___coverage_array[4005] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4006] == 0) {
    {
    fprintf(_coverage_fout, "4006\n");
    fflush(_coverage_fout);
    ___coverage_array[4006] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrint(double __x ) ;
__inline extern long long llrint(double __x ) 
{ long long __llrintres ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4007] == 0) {
    {
    fprintf(_coverage_fout, "4007\n");
    fflush(_coverage_fout);
    ___coverage_array[4007] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4008] == 0) {
    {
    fprintf(_coverage_fout, "4008\n");
    fflush(_coverage_fout);
    ___coverage_array[4008] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintl(long double __x ) ;
__inline extern long long llrintl(long double __x ) 
{ long long __llrintres ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4009] == 0) {
    {
    fprintf(_coverage_fout, "4009\n");
    fflush(_coverage_fout);
    ___coverage_array[4009] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4010] == 0) {
    {
    fprintf(_coverage_fout, "4010\n");
    fflush(_coverage_fout);
    ___coverage_array[4010] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) int __finite(double __x )  __attribute__((__const__)) ;
__inline extern int __finite(double __x ) 
{ union __anonunion_28 __constr_expr_0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4011] == 0) {
    {
    fprintf(_coverage_fout, "4011\n");
    fflush(_coverage_fout);
    ___coverage_array[4011] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __constr_expr_0.__d = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4012] == 0) {
    {
    fprintf(_coverage_fout, "4012\n");
    fflush(_coverage_fout);
    ___coverage_array[4012] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )((((unsigned int )__constr_expr_0.__i[1] | 0x800fffffu) + 1U) >> 31));
}
}
extern struct _IO_FILE_plus _IO_2_1_stdin_ ;
extern struct _IO_FILE_plus _IO_2_1_stdout_ ;
extern struct _IO_FILE_plus _IO_2_1_stderr_ ;
extern void _IO_cookie_init(struct _IO_cookie_file *__cfile , int __read_write ,
                            void *__cookie , _IO_cookie_io_functions_t __fns ) ;
extern int __underflow(_IO_FILE * ) ;
extern int __uflow(_IO_FILE * ) ;
extern int __overflow(_IO_FILE * , int  ) ;
extern int _IO_getc(_IO_FILE *__fp ) ;
extern int _IO_putc(int __c , _IO_FILE *__fp ) ;
extern  __attribute__((__nothrow__)) int _IO_feof(_IO_FILE *__fp ) ;
extern  __attribute__((__nothrow__)) int _IO_ferror(_IO_FILE *__fp ) ;
extern int _IO_peekc_locked(_IO_FILE *__fp ) ;
extern  __attribute__((__nothrow__)) void _IO_flockfile(_IO_FILE * ) ;
extern  __attribute__((__nothrow__)) void _IO_funlockfile(_IO_FILE * ) ;
extern  __attribute__((__nothrow__)) int _IO_ftrylockfile(_IO_FILE * ) ;
extern int _IO_vfscanf(_IO_FILE * __restrict   , char const   * __restrict   ,
                       __gnuc_va_list  , int * __restrict   ) ;
extern int _IO_vfprintf(_IO_FILE * __restrict   , char const   * __restrict   ,
                        __gnuc_va_list  ) ;
extern __ssize_t _IO_padn(_IO_FILE * , int  , __ssize_t  ) ;
extern size_t _IO_sgetn(_IO_FILE * , void * , size_t  ) ;
extern __off64_t _IO_seekoff(_IO_FILE * , __off64_t  , int  , int  ) ;
extern __off64_t _IO_seekpos(_IO_FILE * , __off64_t  , int  ) ;
extern  __attribute__((__nothrow__)) void _IO_free_backup_area(_IO_FILE * ) ;
extern struct _IO_FILE *stdin ;
extern struct _IO_FILE *stdout ;
extern struct _IO_FILE *stderr ;
extern  __attribute__((__nothrow__)) int remove(char const   *__filename ) ;
extern  __attribute__((__nothrow__)) int rename(char const   *__old ,
                                                char const   *__new ) ;
extern  __attribute__((__nothrow__)) int renameat(int __oldfd ,
                                                  char const   *__old ,
                                                  int __newfd ,
                                                  char const   *__new ) ;
extern FILE *tmpfile(void) ;
extern FILE *tmpfile64(void) ;
extern  __attribute__((__nothrow__)) char *tmpnam(char *__s ) ;
extern  __attribute__((__nothrow__)) char *tmpnam_r(char *__s ) ;
extern  __attribute__((__nothrow__)) char *tempnam(char const   *__dir ,
                                                   char const   *__pfx )  __attribute__((__malloc__)) ;
extern int fflush_unlocked(FILE *__stream ) ;
extern int fcloseall(void) ;
extern FILE *freopen(char const   * __restrict  __filename ,
                     char const   * __restrict  __modes ,
                     FILE * __restrict  __stream ) ;
extern FILE *fopen64(char const   * __restrict  __filename ,
                     char const   * __restrict  __modes ) ;
extern FILE *freopen64(char const   * __restrict  __filename ,
                       char const   * __restrict  __modes ,
                       FILE * __restrict  __stream ) ;
extern  __attribute__((__nothrow__)) FILE *fdopen(int __fd ,
                                                  char const   *__modes ) ;
extern  __attribute__((__nothrow__)) FILE *fopencookie(void * __restrict  __magic_cookie ,
                                                       char const   * __restrict  __modes ,
                                                       _IO_cookie_io_functions_t __io_funcs ) ;
extern  __attribute__((__nothrow__)) FILE *fmemopen(void *__s , size_t __len ,
                                                    char const   *__modes ) ;
extern  __attribute__((__nothrow__)) FILE *open_memstream(char **__bufloc ,
                                                          size_t *__sizeloc ) ;
extern  __attribute__((__nothrow__)) void setbuf(FILE * __restrict  __stream ,
                                                 char * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) int setvbuf(FILE * __restrict  __stream ,
                                                 char * __restrict  __buf ,
                                                 int __modes , size_t __n ) ;
extern  __attribute__((__nothrow__)) void setbuffer(FILE * __restrict  __stream ,
                                                    char * __restrict  __buf ,
                                                    size_t __size ) ;
extern  __attribute__((__nothrow__)) void setlinebuf(FILE *__stream ) ;
extern int printf(char const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) int sprintf(char * __restrict  __s ,
                                                 char const   * __restrict  __format 
                                                 , ...) ;
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 ) ;
extern  __attribute__((__nothrow__)) int vsprintf(char * __restrict  __s ,
                                                  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 ( /* format attribute */  vsnprintf)(char * __restrict  __s ,
                                                                              size_t __maxlen ,
                                                                              char const   * __restrict  __format ,
                                                                              __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vasprintf)(char ** __restrict  __ptr ,
                                                                              char const   * __restrict  __f ,
                                                                              __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 int ( /* format attribute */  vdprintf)(int __fd ,
                                               char const   * __restrict  __fmt ,
                                               __gnuc_va_list __arg ) ;
extern int ( /* format attribute */  dprintf)(int __fd ,
                                              char const   * __restrict  __fmt 
                                              , ...) ;
extern int fscanf(FILE * __restrict  __stream ,
                  char const   * __restrict  __format  , ...) ;
extern int scanf(char const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) int sscanf(char const   * __restrict  __s ,
                                                char const   * __restrict  __format 
                                                , ...) ;
extern int ( /* format attribute */  vfscanf)(FILE * __restrict  __s ,
                                              char const   * __restrict  __format ,
                                              __gnuc_va_list __arg ) ;
extern int ( /* format attribute */  vscanf)(char const   * __restrict  __format ,
                                             __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vsscanf)(char const   * __restrict  __s ,
                                                                            char const   * __restrict  __format ,
                                                                            __gnuc_va_list __arg ) ;
extern int fgetc(FILE *__stream ) ;
extern int getc(FILE *__stream ) ;
__inline extern int getchar(void) ;
__inline extern int getc_unlocked(FILE *__fp ) ;
__inline extern int getchar_unlocked(void) ;
__inline extern int fgetc_unlocked(FILE *__fp ) ;
extern int fputc(int __c , FILE *__stream ) ;
extern int putc(int __c , FILE *__stream ) ;
__inline extern int putchar(int __c ) ;
__inline extern int fputc_unlocked(int __c , FILE *__stream ) ;
__inline extern int putc_unlocked(int __c , FILE *__stream ) ;
__inline extern int putchar_unlocked(int __c ) ;
extern int getw(FILE *__stream ) ;
extern int putw(int __w , FILE *__stream ) ;
extern char *fgets(char * __restrict  __s , int __n ,
                   FILE * __restrict  __stream ) ;
extern char *gets(char *__s ) ;
extern char *fgets_unlocked(char * __restrict  __s , int __n ,
                            FILE * __restrict  __stream ) ;
extern __ssize_t __getdelim(char ** __restrict  __lineptr ,
                            size_t * __restrict  __n , int __delimiter ,
                            FILE * __restrict  __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 ) ;
extern int fputs(char const   * __restrict  __s , FILE * __restrict  __stream ) ;
extern int puts(char const   *__s ) ;
extern int ungetc(int __c , FILE *__stream ) ;
extern size_t fread(void * __restrict  __ptr , size_t __size , size_t __n ,
                    FILE * __restrict  __stream ) ;
extern size_t fwrite(void const   * __restrict  __ptr , size_t __size ,
                     size_t __n , FILE * __restrict  __s ) ;
extern int fputs_unlocked(char const   * __restrict  __s ,
                          FILE * __restrict  __stream ) ;
extern size_t fread_unlocked(void * __restrict  __ptr , size_t __size ,
                             size_t __n , FILE * __restrict  __stream ) ;
extern size_t fwrite_unlocked(void const   * __restrict  __ptr , size_t __size ,
                              size_t __n , FILE * __restrict  __stream ) ;
extern int fseek(FILE *__stream , long __off , int __whence ) ;
extern long ftell(FILE *__stream ) ;
extern void rewind(FILE *__stream ) ;
extern int fseeko(FILE *__stream , __off_t __off , int __whence ) ;
extern __off_t ftello(FILE *__stream ) ;
extern int fgetpos(FILE * __restrict  __stream , fpos_t * __restrict  __pos ) ;
extern int fsetpos(FILE *__stream , fpos_t const   *__pos ) ;
extern int fseeko64(FILE *__stream , __off64_t __off , int __whence ) ;
extern __off64_t ftello64(FILE *__stream ) ;
extern int fgetpos64(FILE * __restrict  __stream , fpos64_t * __restrict  __pos ) ;
extern int fsetpos64(FILE *__stream , fpos64_t const   *__pos ) ;
extern  __attribute__((__nothrow__)) void clearerr(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int feof(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int ferror(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) void clearerr_unlocked(FILE *__stream ) ;
__inline extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
__inline extern  __attribute__((__nothrow__)) int ferror_unlocked(FILE *__stream ) ;
extern void perror(char const   *__s ) ;
extern int sys_nerr ;
extern char const   * const  sys_errlist[] ;
extern int _sys_nerr ;
extern char const   * const  _sys_errlist[] ;
extern  __attribute__((__nothrow__)) int fileno(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int fileno_unlocked(FILE *__stream ) ;
extern FILE *popen(char const   *__command , char const   *__modes ) ;
extern int pclose(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) char *ctermid(char *__s ) ;
extern char *cuserid(char *__s ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  obstack_printf)(struct obstack * __restrict  __obstack ,
                                                                                   char const   * __restrict  __format 
                                                                                   , ...) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  obstack_vprintf)(struct obstack * __restrict  __obstack ,
                                                                                    char const   * __restrict  __format ,
                                                                                    __gnuc_va_list __args ) ;
extern  __attribute__((__nothrow__)) void flockfile(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) int ftrylockfile(FILE *__stream ) ;
extern  __attribute__((__nothrow__)) void funlockfile(FILE *__stream ) ;
__inline extern int vprintf(char const   * __restrict  __fmt ,
                            __gnuc_va_list __arg ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4013] == 0) {
    {
    fprintf(_coverage_fout, "4013\n");
    fflush(_coverage_fout);
    ___coverage_array[4013] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = vfprintf((FILE */* __restrict  */)stdout, __fmt, __arg);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4014] == 0) {
    {
    fprintf(_coverage_fout, "4014\n");
    fflush(_coverage_fout);
    ___coverage_array[4014] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int getchar(void) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4015] == 0) {
    {
    fprintf(_coverage_fout, "4015\n");
    fflush(_coverage_fout);
    ___coverage_array[4015] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _IO_getc(stdin);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4016] == 0) {
    {
    fprintf(_coverage_fout, "4016\n");
    fflush(_coverage_fout);
    ___coverage_array[4016] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int fgetc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4022] == 0) {
    {
    fprintf(_coverage_fout, "4022\n");
    fflush(_coverage_fout);
    ___coverage_array[4022] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4023] == 0) {
    {
    fprintf(_coverage_fout, "4023\n");
    fflush(_coverage_fout);
    ___coverage_array[4023] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4017] == 0) {
      {
      fprintf(_coverage_fout, "4017\n");
      fflush(_coverage_fout);
      ___coverage_array[4017] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4018] == 0) {
      {
      fprintf(_coverage_fout, "4018\n");
      fflush(_coverage_fout);
      ___coverage_array[4018] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4019] == 0) {
      {
      fprintf(_coverage_fout, "4019\n");
      fflush(_coverage_fout);
      ___coverage_array[4019] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4020] == 0) {
      {
      fprintf(_coverage_fout, "4020\n");
      fflush(_coverage_fout);
      ___coverage_array[4020] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4021] == 0) {
      {
      fprintf(_coverage_fout, "4021\n");
      fflush(_coverage_fout);
      ___coverage_array[4021] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4024] == 0) {
    {
    fprintf(_coverage_fout, "4024\n");
    fflush(_coverage_fout);
    ___coverage_array[4024] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int getc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4030] == 0) {
    {
    fprintf(_coverage_fout, "4030\n");
    fflush(_coverage_fout);
    ___coverage_array[4030] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4031] == 0) {
    {
    fprintf(_coverage_fout, "4031\n");
    fflush(_coverage_fout);
    ___coverage_array[4031] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4025] == 0) {
      {
      fprintf(_coverage_fout, "4025\n");
      fflush(_coverage_fout);
      ___coverage_array[4025] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4026] == 0) {
      {
      fprintf(_coverage_fout, "4026\n");
      fflush(_coverage_fout);
      ___coverage_array[4026] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4027] == 0) {
      {
      fprintf(_coverage_fout, "4027\n");
      fflush(_coverage_fout);
      ___coverage_array[4027] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4028] == 0) {
      {
      fprintf(_coverage_fout, "4028\n");
      fflush(_coverage_fout);
      ___coverage_array[4028] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4029] == 0) {
      {
      fprintf(_coverage_fout, "4029\n");
      fflush(_coverage_fout);
      ___coverage_array[4029] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4032] == 0) {
    {
    fprintf(_coverage_fout, "4032\n");
    fflush(_coverage_fout);
    ___coverage_array[4032] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int getchar_unlocked(void) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4038] == 0) {
    {
    fprintf(_coverage_fout, "4038\n");
    fflush(_coverage_fout);
    ___coverage_array[4038] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )stdin->_IO_read_ptr >= (unsigned int )stdin->_IO_read_end),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4039] == 0) {
    {
    fprintf(_coverage_fout, "4039\n");
    fflush(_coverage_fout);
    ___coverage_array[4039] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4033] == 0) {
      {
      fprintf(_coverage_fout, "4033\n");
      fflush(_coverage_fout);
      ___coverage_array[4033] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __uflow(stdin);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4034] == 0) {
      {
      fprintf(_coverage_fout, "4034\n");
      fflush(_coverage_fout);
      ___coverage_array[4034] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4035] == 0) {
      {
      fprintf(_coverage_fout, "4035\n");
      fflush(_coverage_fout);
      ___coverage_array[4035] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = stdin->_IO_read_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4036] == 0) {
      {
      fprintf(_coverage_fout, "4036\n");
      fflush(_coverage_fout);
      ___coverage_array[4036] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (stdin->_IO_read_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4037] == 0) {
      {
      fprintf(_coverage_fout, "4037\n");
      fflush(_coverage_fout);
      ___coverage_array[4037] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4040] == 0) {
    {
    fprintf(_coverage_fout, "4040\n");
    fflush(_coverage_fout);
    ___coverage_array[4040] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int putchar(int __c ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4041] == 0) {
    {
    fprintf(_coverage_fout, "4041\n");
    fflush(_coverage_fout);
    ___coverage_array[4041] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _IO_putc(__c, stdout);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4042] == 0) {
    {
    fprintf(_coverage_fout, "4042\n");
    fflush(_coverage_fout);
    ___coverage_array[4042] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4050] == 0) {
    {
    fprintf(_coverage_fout, "4050\n");
    fflush(_coverage_fout);
    ___coverage_array[4050] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4051] == 0) {
    {
    fprintf(_coverage_fout, "4051\n");
    fflush(_coverage_fout);
    ___coverage_array[4051] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4043] == 0) {
      {
      fprintf(_coverage_fout, "4043\n");
      fflush(_coverage_fout);
      ___coverage_array[4043] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4044] == 0) {
      {
      fprintf(_coverage_fout, "4044\n");
      fflush(_coverage_fout);
      ___coverage_array[4044] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4045] == 0) {
      {
      fprintf(_coverage_fout, "4045\n");
      fflush(_coverage_fout);
      ___coverage_array[4045] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4046] == 0) {
      {
      fprintf(_coverage_fout, "4046\n");
      fflush(_coverage_fout);
      ___coverage_array[4046] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4047] == 0) {
      {
      fprintf(_coverage_fout, "4047\n");
      fflush(_coverage_fout);
      ___coverage_array[4047] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4048] == 0) {
      {
      fprintf(_coverage_fout, "4048\n");
      fflush(_coverage_fout);
      ___coverage_array[4048] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4049] == 0) {
      {
      fprintf(_coverage_fout, "4049\n");
      fflush(_coverage_fout);
      ___coverage_array[4049] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4052] == 0) {
    {
    fprintf(_coverage_fout, "4052\n");
    fflush(_coverage_fout);
    ___coverage_array[4052] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___3);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4060] == 0) {
    {
    fprintf(_coverage_fout, "4060\n");
    fflush(_coverage_fout);
    ___coverage_array[4060] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4061] == 0) {
    {
    fprintf(_coverage_fout, "4061\n");
    fflush(_coverage_fout);
    ___coverage_array[4061] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4053] == 0) {
      {
      fprintf(_coverage_fout, "4053\n");
      fflush(_coverage_fout);
      ___coverage_array[4053] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4054] == 0) {
      {
      fprintf(_coverage_fout, "4054\n");
      fflush(_coverage_fout);
      ___coverage_array[4054] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4055] == 0) {
      {
      fprintf(_coverage_fout, "4055\n");
      fflush(_coverage_fout);
      ___coverage_array[4055] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4056] == 0) {
      {
      fprintf(_coverage_fout, "4056\n");
      fflush(_coverage_fout);
      ___coverage_array[4056] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4057] == 0) {
      {
      fprintf(_coverage_fout, "4057\n");
      fflush(_coverage_fout);
      ___coverage_array[4057] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4058] == 0) {
      {
      fprintf(_coverage_fout, "4058\n");
      fflush(_coverage_fout);
      ___coverage_array[4058] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4059] == 0) {
      {
      fprintf(_coverage_fout, "4059\n");
      fflush(_coverage_fout);
      ___coverage_array[4059] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4062] == 0) {
    {
    fprintf(_coverage_fout, "4062\n");
    fflush(_coverage_fout);
    ___coverage_array[4062] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern int putchar_unlocked(int __c ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4070] == 0) {
    {
    fprintf(_coverage_fout, "4070\n");
    fflush(_coverage_fout);
    ___coverage_array[4070] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )stdout->_IO_write_ptr >= (unsigned int )stdout->_IO_write_end),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4071] == 0) {
    {
    fprintf(_coverage_fout, "4071\n");
    fflush(_coverage_fout);
    ___coverage_array[4071] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4063] == 0) {
      {
      fprintf(_coverage_fout, "4063\n");
      fflush(_coverage_fout);
      ___coverage_array[4063] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __overflow(stdout, (int )((unsigned char )__c));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4064] == 0) {
      {
      fprintf(_coverage_fout, "4064\n");
      fflush(_coverage_fout);
      ___coverage_array[4064] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4065] == 0) {
      {
      fprintf(_coverage_fout, "4065\n");
      fflush(_coverage_fout);
      ___coverage_array[4065] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = stdout->_IO_write_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4066] == 0) {
      {
      fprintf(_coverage_fout, "4066\n");
      fflush(_coverage_fout);
      ___coverage_array[4066] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (stdout->_IO_write_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4067] == 0) {
      {
      fprintf(_coverage_fout, "4067\n");
      fflush(_coverage_fout);
      ___coverage_array[4067] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4068] == 0) {
      {
      fprintf(_coverage_fout, "4068\n");
      fflush(_coverage_fout);
      ___coverage_array[4068] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4069] == 0) {
      {
      fprintf(_coverage_fout, "4069\n");
      fflush(_coverage_fout);
      ___coverage_array[4069] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4072] == 0) {
    {
    fprintf(_coverage_fout, "4072\n");
    fflush(_coverage_fout);
    ___coverage_array[4072] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern __ssize_t getline(char ** __restrict  __lineptr ,
                                  size_t * __restrict  __n ,
                                  FILE * __restrict  __stream ) 
{ __ssize_t tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4073] == 0) {
    {
    fprintf(_coverage_fout, "4073\n");
    fflush(_coverage_fout);
    ___coverage_array[4073] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __getdelim(__lineptr, __n, '\n', __stream);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4074] == 0) {
    {
    fprintf(_coverage_fout, "4074\n");
    fflush(_coverage_fout);
    ___coverage_array[4074] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
__inline extern int feof_unlocked(FILE *__stream ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4075] == 0) {
    {
    fprintf(_coverage_fout, "4075\n");
    fflush(_coverage_fout);
    ___coverage_array[4075] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((__stream->_flags & 0x10) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) int ferror_unlocked(FILE *__stream ) ;
__inline extern int ferror_unlocked(FILE *__stream ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4076] == 0) {
    {
    fprintf(_coverage_fout, "4076\n");
    fflush(_coverage_fout);
    ___coverage_array[4076] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((__stream->_flags & 0x20) != 0);
}
}
extern  __attribute__((__nothrow__)) void _dl_mcount_wrapper_check(void *__selfpc ) ;
extern  __attribute__((__nothrow__)) void *dlopen(char const   *__file ,
                                                  int __mode ) ;
extern  __attribute__((__nothrow__)) int dlclose(void *__handle )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void *dlsym(void * __restrict  __handle ,
                                                 char const   * __restrict  __name )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) void *dlmopen(Lmid_t __nsid ,
                                                   char const   *__file ,
                                                   int __mode ) ;
extern  __attribute__((__nothrow__)) void *dlvsym(void * __restrict  __handle ,
                                                  char const   * __restrict  __name ,
                                                  char const   * __restrict  __version )  __attribute__((__nonnull__(2,3))) ;
extern  __attribute__((__nothrow__)) char *dlerror(void) ;
extern  __attribute__((__nothrow__)) int dladdr(void const   *__address ,
                                                Dl_info *__info )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int dladdr1(void const   *__address ,
                                                 Dl_info *__info ,
                                                 void **__extra_info ,
                                                 int __flags )  __attribute__((__nonnull__(2))) ;
extern  __attribute__((__nothrow__)) int dlinfo(void * __restrict  __handle ,
                                                int __request ,
                                                void * __restrict  __arg )  __attribute__((__nonnull__(1,3))) ;
extern char __attribute__((__visibility__("default")))  *zend_strndup(char const   *s ,
                                                                      unsigned int length )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  *_emalloc(size_t size )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  *_safe_emalloc(size_t nmemb ,
                                                                       size_t size ,
                                                                       size_t offset )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  *_safe_malloc(size_t nmemb ,
                                                                      size_t size ,
                                                                      size_t offset )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  _efree(void *ptr ) ;
extern void __attribute__((__visibility__("default")))  *_ecalloc(size_t nmemb ,
                                                                  size_t size )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  *_erealloc(void *ptr ,
                                                                   size_t size ,
                                                                   int allow_failure ) ;
extern void __attribute__((__visibility__("default")))  *_safe_erealloc(void *ptr ,
                                                                        size_t nmemb ,
                                                                        size_t size ,
                                                                        size_t offset ) ;
extern void __attribute__((__visibility__("default")))  *_safe_realloc(void *ptr ,
                                                                       size_t nmemb ,
                                                                       size_t size ,
                                                                       size_t offset ) ;
extern char __attribute__((__visibility__("default")))  *_estrdup(char const   *s )  __attribute__((__malloc__)) ;
extern char __attribute__((__visibility__("default")))  *_estrndup(char const   *s ,
                                                                   unsigned int length )  __attribute__((__malloc__)) ;
extern size_t __attribute__((__visibility__("default")))  _zend_mem_block_size(void *ptr ) ;
__inline static void *__zend_malloc(size_t len ) 
{ void *tmp ;
  void *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4079] == 0) {
    {
    fprintf(_coverage_fout, "4079\n");
    fflush(_coverage_fout);
    ___coverage_array[4079] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = malloc(len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4080] == 0) {
    {
    fprintf(_coverage_fout, "4080\n");
    fflush(_coverage_fout);
    ___coverage_array[4080] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4081] == 0) {
    {
    fprintf(_coverage_fout, "4081\n");
    fflush(_coverage_fout);
    ___coverage_array[4081] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4077] == 0) {
      {
      fprintf(_coverage_fout, "4077\n");
      fflush(_coverage_fout);
      ___coverage_array[4077] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4078] == 0) {
      {
      fprintf(_coverage_fout, "4078\n");
      fflush(_coverage_fout);
      ___coverage_array[4078] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4082] == 0) {
    {
    fprintf(_coverage_fout, "4082\n");
    fflush(_coverage_fout);
    ___coverage_array[4082] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stderr,
          (char const   */* __restrict  */)"Out of memory\n");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4083] == 0) {
    {
    fprintf(_coverage_fout, "4083\n");
    fflush(_coverage_fout);
    ___coverage_array[4083] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  exit(1);
}
}
__inline static void *__zend_calloc(size_t nmemb , size_t len ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4084] == 0) {
    {
    fprintf(_coverage_fout, "4084\n");
    fflush(_coverage_fout);
    ___coverage_array[4084] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = _safe_malloc(nmemb, len, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4085] == 0) {
    {
    fprintf(_coverage_fout, "4085\n");
    fflush(_coverage_fout);
    ___coverage_array[4085] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (void *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4086] == 0) {
    {
    fprintf(_coverage_fout, "4086\n");
    fflush(_coverage_fout);
    ___coverage_array[4086] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset(tmp, 0, nmemb * len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4087] == 0) {
    {
    fprintf(_coverage_fout, "4087\n");
    fflush(_coverage_fout);
    ___coverage_array[4087] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline static void *__zend_realloc(void *p , size_t len ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4090] == 0) {
    {
    fprintf(_coverage_fout, "4090\n");
    fflush(_coverage_fout);
    ___coverage_array[4090] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = realloc(p, len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4091] == 0) {
    {
    fprintf(_coverage_fout, "4091\n");
    fflush(_coverage_fout);
    ___coverage_array[4091] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (p) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4088] == 0) {
      {
      fprintf(_coverage_fout, "4088\n");
      fflush(_coverage_fout);
      ___coverage_array[4088] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4089] == 0) {
      {
      fprintf(_coverage_fout, "4089\n");
      fflush(_coverage_fout);
      ___coverage_array[4089] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4092] == 0) {
    {
    fprintf(_coverage_fout, "4092\n");
    fflush(_coverage_fout);
    ___coverage_array[4092] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stderr,
          (char const   */* __restrict  */)"Out of memory\n");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4093] == 0) {
    {
    fprintf(_coverage_fout, "4093\n");
    fflush(_coverage_fout);
    ___coverage_array[4093] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  exit(1);
}
}
extern int __attribute__((__visibility__("default")))  zend_set_memory_limit(size_t memory_limit ) ;
extern void __attribute__((__visibility__("default")))  start_memory_manager(void) ;
extern void __attribute__((__visibility__("default")))  shutdown_memory_manager(int silent ,
                                                                                int full_shutdown ) ;
extern int __attribute__((__visibility__("default")))  is_zend_mm(void) ;
extern size_t __attribute__((__visibility__("default")))  zend_memory_usage(int real_usage ) ;
extern size_t __attribute__((__visibility__("default")))  zend_memory_peak_usage(int real_usage ) ;
extern zend_mm_heap __attribute__((__visibility__("default")))  *zend_mm_startup(void) ;
extern void __attribute__((__visibility__("default")))  zend_mm_shutdown(zend_mm_heap *heap ,
                                                                         int full_shutdown ,
                                                                         int silent ) ;
extern void __attribute__((__visibility__("default")))  *_zend_mm_alloc(zend_mm_heap *heap ,
                                                                        size_t size )  __attribute__((__malloc__)) ;
extern void __attribute__((__visibility__("default")))  _zend_mm_free(zend_mm_heap *heap ,
                                                                      void *p ) ;
extern void __attribute__((__visibility__("default")))  *_zend_mm_realloc(zend_mm_heap *heap ,
                                                                          void *p ,
                                                                          size_t size ) ;
extern size_t __attribute__((__visibility__("default")))  _zend_mm_block_size(zend_mm_heap *heap ,
                                                                              void *p ) ;
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 zend_mm_heap __attribute__((__visibility__("default")))  *zend_mm_set_heap(zend_mm_heap *new_heap ) ;
extern zend_mm_storage __attribute__((__visibility__("default")))  *zend_mm_get_storage(zend_mm_heap *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  ) ) ;
extern char const __attribute__((__visibility__("default")))  *(*zend_new_interned_string)(char const   *str ,
                                                                                           int len ,
                                                                                           int free_src ) ;
extern void __attribute__((__visibility__("default")))  (*zend_interned_strings_snapshot)(void) ;
extern void __attribute__((__visibility__("default")))  (*zend_interned_strings_restore)(void) ;
extern void zend_interned_strings_init(void) ;
extern void zend_interned_strings_dtor(void) ;
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 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 ) ;
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 void __attribute__((__visibility__("default")))  zend_hash_destroy(HashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_clean(HashTable *ht ) ;
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_quick_add_or_update(HashTable *ht ,
                                                                                      char const   *arKey ,
                                                                                      uint nKeyLength ,
                                                                                      ulong h ,
                                                                                      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 ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_add_empty_element(HashTable *ht ,
                                                                                   char const   *arKey ,
                                                                                   uint nKeyLength ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_graceful_destroy(HashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_graceful_reverse_destroy(HashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_apply(HashTable *ht ,
                                                                        int (*apply_func)(void *pDest ) ) ;
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_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_reverse_apply(HashTable *ht ,
                                                                                int (*apply_func)(void *pDest ) ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_del_key_or_index(HashTable *ht ,
                                                                                  char const   *arKey ,
                                                                                  uint nKeyLength ,
                                                                                  ulong h ,
                                                                                  int flag ) ;
extern ulong __attribute__((__visibility__("default")))  zend_get_hash_value(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_quick_find(HashTable const   *ht ,
                                                                            char const   *arKey ,
                                                                            uint nKeyLength ,
                                                                            ulong h ,
                                                                            void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_index_find(HashTable const   *ht ,
                                                                            ulong h ,
                                                                            void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_exists(HashTable const   *ht ,
                                                                        char const   *arKey ,
                                                                        uint nKeyLength ) ;
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_index_exists(HashTable const   *ht ,
                                                                              ulong h ) ;
extern ulong __attribute__((__visibility__("default")))  zend_hash_next_free_element(HashTable const   *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_move_forward_ex(HashTable *ht ,
                                                                                 HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_move_backwards_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_get_current_key_type_ex(HashTable *ht ,
                                                                                         HashPosition *pos ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_get_current_data_ex(HashTable *ht ,
                                                                                     void **pData ,
                                                                                     HashPosition *pos ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_internal_pointer_reset_ex(HashTable *ht ,
                                                                                            HashPosition *pos ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_internal_pointer_end_ex(HashTable *ht ,
                                                                                          HashPosition *pos ) ;
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 ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_get_pointer(HashTable const   *ht ,
                                                                             HashPointer *ptr ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_set_pointer(HashTable *ht ,
                                                                             HashPointer const   *ptr ) ;
extern void __attribute__((__visibility__("default")))  zend_hash_copy(HashTable *target ,
                                                                       HashTable *source ,
                                                                       void (*pCopyConstructor)(void *pElement ) ,
                                                                       void *tmp ,
                                                                       uint size ) ;
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_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 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 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_minmax(HashTable const   *ht ,
                                                                        int (*compar)(void const   * ,
                                                                                      void const   * ) ,
                                                                        int flag ,
                                                                        void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_num_elements(HashTable const   *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_hash_rehash(HashTable *ht ) ;
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4142] == 0) {
    {
    fprintf(_coverage_fout, "4142\n");
    fflush(_coverage_fout);
    ___coverage_array[4142] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = (ulong )5381;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4143] == 0) {
    {
    fprintf(_coverage_fout, "4143\n");
    fflush(_coverage_fout);
    ___coverage_array[4143] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4095] == 0) {
      {
      fprintf(_coverage_fout, "4095\n");
      fflush(_coverage_fout);
      ___coverage_array[4095] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (nKeyLength >= 8U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4094] == 0) {
        {
        fprintf(_coverage_fout, "4094\n");
        fflush(_coverage_fout);
        ___coverage_array[4094] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4096] == 0) {
      {
      fprintf(_coverage_fout, "4096\n");
      fflush(_coverage_fout);
      ___coverage_array[4096] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4097] == 0) {
      {
      fprintf(_coverage_fout, "4097\n");
      fflush(_coverage_fout);
      ___coverage_array[4097] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4098] == 0) {
      {
      fprintf(_coverage_fout, "4098\n");
      fflush(_coverage_fout);
      ___coverage_array[4098] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4099] == 0) {
      {
      fprintf(_coverage_fout, "4099\n");
      fflush(_coverage_fout);
      ___coverage_array[4099] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4100] == 0) {
      {
      fprintf(_coverage_fout, "4100\n");
      fflush(_coverage_fout);
      ___coverage_array[4100] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4101] == 0) {
      {
      fprintf(_coverage_fout, "4101\n");
      fflush(_coverage_fout);
      ___coverage_array[4101] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4102] == 0) {
      {
      fprintf(_coverage_fout, "4102\n");
      fflush(_coverage_fout);
      ___coverage_array[4102] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4103] == 0) {
      {
      fprintf(_coverage_fout, "4103\n");
      fflush(_coverage_fout);
      ___coverage_array[4103] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4104] == 0) {
      {
      fprintf(_coverage_fout, "4104\n");
      fflush(_coverage_fout);
      ___coverage_array[4104] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4105] == 0) {
      {
      fprintf(_coverage_fout, "4105\n");
      fflush(_coverage_fout);
      ___coverage_array[4105] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4106] == 0) {
      {
      fprintf(_coverage_fout, "4106\n");
      fflush(_coverage_fout);
      ___coverage_array[4106] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4107] == 0) {
      {
      fprintf(_coverage_fout, "4107\n");
      fflush(_coverage_fout);
      ___coverage_array[4107] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4108] == 0) {
      {
      fprintf(_coverage_fout, "4108\n");
      fflush(_coverage_fout);
      ___coverage_array[4108] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4109] == 0) {
      {
      fprintf(_coverage_fout, "4109\n");
      fflush(_coverage_fout);
      ___coverage_array[4109] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4110] == 0) {
      {
      fprintf(_coverage_fout, "4110\n");
      fflush(_coverage_fout);
      ___coverage_array[4110] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4111] == 0) {
      {
      fprintf(_coverage_fout, "4111\n");
      fflush(_coverage_fout);
      ___coverage_array[4111] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4112] == 0) {
      {
      fprintf(_coverage_fout, "4112\n");
      fflush(_coverage_fout);
      ___coverage_array[4112] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4113] == 0) {
      {
      fprintf(_coverage_fout, "4113\n");
      fflush(_coverage_fout);
      ___coverage_array[4113] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___4;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4114] == 0) {
      {
      fprintf(_coverage_fout, "4114\n");
      fflush(_coverage_fout);
      ___coverage_array[4114] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4115] == 0) {
      {
      fprintf(_coverage_fout, "4115\n");
      fflush(_coverage_fout);
      ___coverage_array[4115] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4116] == 0) {
      {
      fprintf(_coverage_fout, "4116\n");
      fflush(_coverage_fout);
      ___coverage_array[4116] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___5;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4117] == 0) {
      {
      fprintf(_coverage_fout, "4117\n");
      fflush(_coverage_fout);
      ___coverage_array[4117] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4118] == 0) {
      {
      fprintf(_coverage_fout, "4118\n");
      fflush(_coverage_fout);
      ___coverage_array[4118] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4119] == 0) {
      {
      fprintf(_coverage_fout, "4119\n");
      fflush(_coverage_fout);
      ___coverage_array[4119] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___6;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4120] == 0) {
      {
      fprintf(_coverage_fout, "4120\n");
      fflush(_coverage_fout);
      ___coverage_array[4120] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    nKeyLength -= 8U;
  }
  switch ((int )nKeyLength) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4121] == 0) {
    {
    fprintf(_coverage_fout, "4121\n");
    fflush(_coverage_fout);
    ___coverage_array[4121] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 7: 
  tmp___7 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4122] == 0) {
    {
    fprintf(_coverage_fout, "4122\n");
    fflush(_coverage_fout);
    ___coverage_array[4122] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4123] == 0) {
    {
    fprintf(_coverage_fout, "4123\n");
    fflush(_coverage_fout);
    ___coverage_array[4123] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___7;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4124] == 0) {
    {
    fprintf(_coverage_fout, "4124\n");
    fflush(_coverage_fout);
    ___coverage_array[4124] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 6: 
  tmp___8 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4125] == 0) {
    {
    fprintf(_coverage_fout, "4125\n");
    fflush(_coverage_fout);
    ___coverage_array[4125] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4126] == 0) {
    {
    fprintf(_coverage_fout, "4126\n");
    fflush(_coverage_fout);
    ___coverage_array[4126] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___8;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4127] == 0) {
    {
    fprintf(_coverage_fout, "4127\n");
    fflush(_coverage_fout);
    ___coverage_array[4127] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 5: 
  tmp___9 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4128] == 0) {
    {
    fprintf(_coverage_fout, "4128\n");
    fflush(_coverage_fout);
    ___coverage_array[4128] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4129] == 0) {
    {
    fprintf(_coverage_fout, "4129\n");
    fflush(_coverage_fout);
    ___coverage_array[4129] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___9;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4130] == 0) {
    {
    fprintf(_coverage_fout, "4130\n");
    fflush(_coverage_fout);
    ___coverage_array[4130] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 4: 
  tmp___10 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4131] == 0) {
    {
    fprintf(_coverage_fout, "4131\n");
    fflush(_coverage_fout);
    ___coverage_array[4131] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4132] == 0) {
    {
    fprintf(_coverage_fout, "4132\n");
    fflush(_coverage_fout);
    ___coverage_array[4132] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___10;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4133] == 0) {
    {
    fprintf(_coverage_fout, "4133\n");
    fflush(_coverage_fout);
    ___coverage_array[4133] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  tmp___11 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4134] == 0) {
    {
    fprintf(_coverage_fout, "4134\n");
    fflush(_coverage_fout);
    ___coverage_array[4134] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4135] == 0) {
    {
    fprintf(_coverage_fout, "4135\n");
    fflush(_coverage_fout);
    ___coverage_array[4135] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___11;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4136] == 0) {
    {
    fprintf(_coverage_fout, "4136\n");
    fflush(_coverage_fout);
    ___coverage_array[4136] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  tmp___12 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4137] == 0) {
    {
    fprintf(_coverage_fout, "4137\n");
    fflush(_coverage_fout);
    ___coverage_array[4137] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4138] == 0) {
    {
    fprintf(_coverage_fout, "4138\n");
    fflush(_coverage_fout);
    ___coverage_array[4138] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___12;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4139] == 0) {
    {
    fprintf(_coverage_fout, "4139\n");
    fflush(_coverage_fout);
    ___coverage_array[4139] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___13 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4140] == 0) {
    {
    fprintf(_coverage_fout, "4140\n");
    fflush(_coverage_fout);
    ___coverage_array[4140] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4141] == 0) {
    {
    fprintf(_coverage_fout, "4141\n");
    fflush(_coverage_fout);
    ___coverage_array[4141] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___13;
  break;
  case 0: 
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4144] == 0) {
    {
    fprintf(_coverage_fout, "4144\n");
    fflush(_coverage_fout);
    ___coverage_array[4144] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (hash);
}
}
extern ulong __attribute__((__visibility__("default")))  zend_hash_func(char const   *arKey ,
                                                                        uint nKeyLength ) ;
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4181] == 0) {
    {
    fprintf(_coverage_fout, "4181\n");
    fflush(_coverage_fout);
    ___coverage_array[4181] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4180] == 0) {
      {
      fprintf(_coverage_fout, "4180\n");
      fflush(_coverage_fout);
      ___coverage_array[4180] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4177] == 0) {
        {
        fprintf(_coverage_fout, "4177\n");
        fflush(_coverage_fout);
        ___coverage_array[4177] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4178] == 0) {
        {
        fprintf(_coverage_fout, "4178\n");
        fflush(_coverage_fout);
        ___coverage_array[4178] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4145] == 0) {
          {
          fprintf(_coverage_fout, "4145\n");
          fflush(_coverage_fout);
          ___coverage_array[4145] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4146] == 0) {
          {
          fprintf(_coverage_fout, "4146\n");
          fflush(_coverage_fout);
          ___coverage_array[4146] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4179] == 0) {
        {
        fprintf(_coverage_fout, "4179\n");
        fflush(_coverage_fout);
        ___coverage_array[4179] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4175] == 0) {
          {
          fprintf(_coverage_fout, "4175\n");
          fflush(_coverage_fout);
          ___coverage_array[4175] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4169] == 0) {
            {
            fprintf(_coverage_fout, "4169\n");
            fflush(_coverage_fout);
            ___coverage_array[4169] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4170] == 0) {
            {
            fprintf(_coverage_fout, "4170\n");
            fflush(_coverage_fout);
            ___coverage_array[4170] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4153] == 0) {
              {
              fprintf(_coverage_fout, "4153\n");
              fflush(_coverage_fout);
              ___coverage_array[4153] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4147] == 0) {
                {
                fprintf(_coverage_fout, "4147\n");
                fflush(_coverage_fout);
                ___coverage_array[4147] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4152] == 0) {
                {
                fprintf(_coverage_fout, "4152\n");
                fflush(_coverage_fout);
                ___coverage_array[4152] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4151] == 0) {
                  {
                  fprintf(_coverage_fout, "4151\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4151] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4149] == 0) {
                    {
                    fprintf(_coverage_fout, "4149\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4149] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4148] == 0) {
                      {
                      fprintf(_coverage_fout, "4148\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4148] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4150] == 0) {
                    {
                    fprintf(_coverage_fout, "4150\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4150] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4171] == 0) {
            {
            fprintf(_coverage_fout, "4171\n");
            fflush(_coverage_fout);
            ___coverage_array[4171] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4172] == 0) {
            {
            fprintf(_coverage_fout, "4172\n");
            fflush(_coverage_fout);
            ___coverage_array[4172] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4157] == 0) {
              {
              fprintf(_coverage_fout, "4157\n");
              fflush(_coverage_fout);
              ___coverage_array[4157] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4158] == 0) {
              {
              fprintf(_coverage_fout, "4158\n");
              fflush(_coverage_fout);
              ___coverage_array[4158] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4156] == 0) {
                {
                fprintf(_coverage_fout, "4156\n");
                fflush(_coverage_fout);
                ___coverage_array[4156] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4155] == 0) {
                  {
                  fprintf(_coverage_fout, "4155\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4155] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4154] == 0) {
                    {
                    fprintf(_coverage_fout, "4154\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4154] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4159] == 0) {
              {
              fprintf(_coverage_fout, "4159\n");
              fflush(_coverage_fout);
              ___coverage_array[4159] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4173] == 0) {
            {
            fprintf(_coverage_fout, "4173\n");
            fflush(_coverage_fout);
            ___coverage_array[4173] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4165] == 0) {
              {
              fprintf(_coverage_fout, "4165\n");
              fflush(_coverage_fout);
              ___coverage_array[4165] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4161] == 0) {
                {
                fprintf(_coverage_fout, "4161\n");
                fflush(_coverage_fout);
                ___coverage_array[4161] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4160] == 0) {
                  {
                  fprintf(_coverage_fout, "4160\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4160] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4162] == 0) {
                {
                fprintf(_coverage_fout, "4162\n");
                fflush(_coverage_fout);
                ___coverage_array[4162] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4164] == 0) {
                {
                fprintf(_coverage_fout, "4164\n");
                fflush(_coverage_fout);
                ___coverage_array[4164] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4163] == 0) {
                  {
                  fprintf(_coverage_fout, "4163\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4163] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4166] == 0) {
              {
              fprintf(_coverage_fout, "4166\n");
              fflush(_coverage_fout);
              ___coverage_array[4166] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___0 = _zend_hash_index_update_or_next_insert(ht, idx, pData,
                                                             nDataSize, pDest, 1);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4167] == 0) {
              {
              fprintf(_coverage_fout, "4167\n");
              fflush(_coverage_fout);
              ___coverage_array[4167] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4168] == 0) {
              {
              fprintf(_coverage_fout, "4168\n");
              fflush(_coverage_fout);
              ___coverage_array[4168] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4174] == 0) {
            {
            fprintf(_coverage_fout, "4174\n");
            fflush(_coverage_fout);
            ___coverage_array[4174] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4176] == 0) {
          {
          fprintf(_coverage_fout, "4176\n");
          fflush(_coverage_fout);
          ___coverage_array[4176] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4182] == 0) {
    {
    fprintf(_coverage_fout, "4182\n");
    fflush(_coverage_fout);
    ___coverage_array[4182] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize,
                                     pDest, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4183] == 0) {
    {
    fprintf(_coverage_fout, "4183\n");
    fflush(_coverage_fout);
    ___coverage_array[4183] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4220] == 0) {
    {
    fprintf(_coverage_fout, "4220\n");
    fflush(_coverage_fout);
    ___coverage_array[4220] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4219] == 0) {
      {
      fprintf(_coverage_fout, "4219\n");
      fflush(_coverage_fout);
      ___coverage_array[4219] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4216] == 0) {
        {
        fprintf(_coverage_fout, "4216\n");
        fflush(_coverage_fout);
        ___coverage_array[4216] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4217] == 0) {
        {
        fprintf(_coverage_fout, "4217\n");
        fflush(_coverage_fout);
        ___coverage_array[4217] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4184] == 0) {
          {
          fprintf(_coverage_fout, "4184\n");
          fflush(_coverage_fout);
          ___coverage_array[4184] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4185] == 0) {
          {
          fprintf(_coverage_fout, "4185\n");
          fflush(_coverage_fout);
          ___coverage_array[4185] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4218] == 0) {
        {
        fprintf(_coverage_fout, "4218\n");
        fflush(_coverage_fout);
        ___coverage_array[4218] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4214] == 0) {
          {
          fprintf(_coverage_fout, "4214\n");
          fflush(_coverage_fout);
          ___coverage_array[4214] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4208] == 0) {
            {
            fprintf(_coverage_fout, "4208\n");
            fflush(_coverage_fout);
            ___coverage_array[4208] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4209] == 0) {
            {
            fprintf(_coverage_fout, "4209\n");
            fflush(_coverage_fout);
            ___coverage_array[4209] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4192] == 0) {
              {
              fprintf(_coverage_fout, "4192\n");
              fflush(_coverage_fout);
              ___coverage_array[4192] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4186] == 0) {
                {
                fprintf(_coverage_fout, "4186\n");
                fflush(_coverage_fout);
                ___coverage_array[4186] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4191] == 0) {
                {
                fprintf(_coverage_fout, "4191\n");
                fflush(_coverage_fout);
                ___coverage_array[4191] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4190] == 0) {
                  {
                  fprintf(_coverage_fout, "4190\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4190] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4188] == 0) {
                    {
                    fprintf(_coverage_fout, "4188\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4188] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4187] == 0) {
                      {
                      fprintf(_coverage_fout, "4187\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4187] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4189] == 0) {
                    {
                    fprintf(_coverage_fout, "4189\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4189] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4210] == 0) {
            {
            fprintf(_coverage_fout, "4210\n");
            fflush(_coverage_fout);
            ___coverage_array[4210] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4211] == 0) {
            {
            fprintf(_coverage_fout, "4211\n");
            fflush(_coverage_fout);
            ___coverage_array[4211] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4196] == 0) {
              {
              fprintf(_coverage_fout, "4196\n");
              fflush(_coverage_fout);
              ___coverage_array[4196] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4197] == 0) {
              {
              fprintf(_coverage_fout, "4197\n");
              fflush(_coverage_fout);
              ___coverage_array[4197] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4195] == 0) {
                {
                fprintf(_coverage_fout, "4195\n");
                fflush(_coverage_fout);
                ___coverage_array[4195] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4194] == 0) {
                  {
                  fprintf(_coverage_fout, "4194\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4194] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4193] == 0) {
                    {
                    fprintf(_coverage_fout, "4193\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4193] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4198] == 0) {
              {
              fprintf(_coverage_fout, "4198\n");
              fflush(_coverage_fout);
              ___coverage_array[4198] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4212] == 0) {
            {
            fprintf(_coverage_fout, "4212\n");
            fflush(_coverage_fout);
            ___coverage_array[4212] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4204] == 0) {
              {
              fprintf(_coverage_fout, "4204\n");
              fflush(_coverage_fout);
              ___coverage_array[4204] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4200] == 0) {
                {
                fprintf(_coverage_fout, "4200\n");
                fflush(_coverage_fout);
                ___coverage_array[4200] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4199] == 0) {
                  {
                  fprintf(_coverage_fout, "4199\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4199] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4201] == 0) {
                {
                fprintf(_coverage_fout, "4201\n");
                fflush(_coverage_fout);
                ___coverage_array[4201] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4203] == 0) {
                {
                fprintf(_coverage_fout, "4203\n");
                fflush(_coverage_fout);
                ___coverage_array[4203] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4202] == 0) {
                  {
                  fprintf(_coverage_fout, "4202\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4202] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4205] == 0) {
              {
              fprintf(_coverage_fout, "4205\n");
              fflush(_coverage_fout);
              ___coverage_array[4205] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___0 = zend_hash_del_key_or_index(ht,
                                                 (char const   *)((void *)0),
                                                 0U, idx, 1);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4206] == 0) {
              {
              fprintf(_coverage_fout, "4206\n");
              fflush(_coverage_fout);
              ___coverage_array[4206] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4207] == 0) {
              {
              fprintf(_coverage_fout, "4207\n");
              fflush(_coverage_fout);
              ___coverage_array[4207] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4213] == 0) {
            {
            fprintf(_coverage_fout, "4213\n");
            fflush(_coverage_fout);
            ___coverage_array[4213] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4215] == 0) {
          {
          fprintf(_coverage_fout, "4215\n");
          fflush(_coverage_fout);
          ___coverage_array[4215] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4221] == 0) {
    {
    fprintf(_coverage_fout, "4221\n");
    fflush(_coverage_fout);
    ___coverage_array[4221] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0UL, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4222] == 0) {
    {
    fprintf(_coverage_fout, "4222\n");
    fflush(_coverage_fout);
    ___coverage_array[4222] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4259] == 0) {
    {
    fprintf(_coverage_fout, "4259\n");
    fflush(_coverage_fout);
    ___coverage_array[4259] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4258] == 0) {
      {
      fprintf(_coverage_fout, "4258\n");
      fflush(_coverage_fout);
      ___coverage_array[4258] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4255] == 0) {
        {
        fprintf(_coverage_fout, "4255\n");
        fflush(_coverage_fout);
        ___coverage_array[4255] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4256] == 0) {
        {
        fprintf(_coverage_fout, "4256\n");
        fflush(_coverage_fout);
        ___coverage_array[4256] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4223] == 0) {
          {
          fprintf(_coverage_fout, "4223\n");
          fflush(_coverage_fout);
          ___coverage_array[4223] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4224] == 0) {
          {
          fprintf(_coverage_fout, "4224\n");
          fflush(_coverage_fout);
          ___coverage_array[4224] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4257] == 0) {
        {
        fprintf(_coverage_fout, "4257\n");
        fflush(_coverage_fout);
        ___coverage_array[4257] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4253] == 0) {
          {
          fprintf(_coverage_fout, "4253\n");
          fflush(_coverage_fout);
          ___coverage_array[4253] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4247] == 0) {
            {
            fprintf(_coverage_fout, "4247\n");
            fflush(_coverage_fout);
            ___coverage_array[4247] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4248] == 0) {
            {
            fprintf(_coverage_fout, "4248\n");
            fflush(_coverage_fout);
            ___coverage_array[4248] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4231] == 0) {
              {
              fprintf(_coverage_fout, "4231\n");
              fflush(_coverage_fout);
              ___coverage_array[4231] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4225] == 0) {
                {
                fprintf(_coverage_fout, "4225\n");
                fflush(_coverage_fout);
                ___coverage_array[4225] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4230] == 0) {
                {
                fprintf(_coverage_fout, "4230\n");
                fflush(_coverage_fout);
                ___coverage_array[4230] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4229] == 0) {
                  {
                  fprintf(_coverage_fout, "4229\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4229] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4227] == 0) {
                    {
                    fprintf(_coverage_fout, "4227\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4227] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4226] == 0) {
                      {
                      fprintf(_coverage_fout, "4226\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4226] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4228] == 0) {
                    {
                    fprintf(_coverage_fout, "4228\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4228] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4249] == 0) {
            {
            fprintf(_coverage_fout, "4249\n");
            fflush(_coverage_fout);
            ___coverage_array[4249] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4250] == 0) {
            {
            fprintf(_coverage_fout, "4250\n");
            fflush(_coverage_fout);
            ___coverage_array[4250] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4235] == 0) {
              {
              fprintf(_coverage_fout, "4235\n");
              fflush(_coverage_fout);
              ___coverage_array[4235] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4236] == 0) {
              {
              fprintf(_coverage_fout, "4236\n");
              fflush(_coverage_fout);
              ___coverage_array[4236] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4234] == 0) {
                {
                fprintf(_coverage_fout, "4234\n");
                fflush(_coverage_fout);
                ___coverage_array[4234] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4233] == 0) {
                  {
                  fprintf(_coverage_fout, "4233\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4233] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4232] == 0) {
                    {
                    fprintf(_coverage_fout, "4232\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4232] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4237] == 0) {
              {
              fprintf(_coverage_fout, "4237\n");
              fflush(_coverage_fout);
              ___coverage_array[4237] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4251] == 0) {
            {
            fprintf(_coverage_fout, "4251\n");
            fflush(_coverage_fout);
            ___coverage_array[4251] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4243] == 0) {
              {
              fprintf(_coverage_fout, "4243\n");
              fflush(_coverage_fout);
              ___coverage_array[4243] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4239] == 0) {
                {
                fprintf(_coverage_fout, "4239\n");
                fflush(_coverage_fout);
                ___coverage_array[4239] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4238] == 0) {
                  {
                  fprintf(_coverage_fout, "4238\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4238] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4240] == 0) {
                {
                fprintf(_coverage_fout, "4240\n");
                fflush(_coverage_fout);
                ___coverage_array[4240] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4242] == 0) {
                {
                fprintf(_coverage_fout, "4242\n");
                fflush(_coverage_fout);
                ___coverage_array[4242] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4241] == 0) {
                  {
                  fprintf(_coverage_fout, "4241\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4241] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4244] == 0) {
              {
              fprintf(_coverage_fout, "4244\n");
              fflush(_coverage_fout);
              ___coverage_array[4244] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___0 = zend_hash_index_find((HashTable const   *)ht, idx, pData);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4245] == 0) {
              {
              fprintf(_coverage_fout, "4245\n");
              fflush(_coverage_fout);
              ___coverage_array[4245] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4246] == 0) {
              {
              fprintf(_coverage_fout, "4246\n");
              fflush(_coverage_fout);
              ___coverage_array[4246] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4252] == 0) {
            {
            fprintf(_coverage_fout, "4252\n");
            fflush(_coverage_fout);
            ___coverage_array[4252] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4254] == 0) {
          {
          fprintf(_coverage_fout, "4254\n");
          fflush(_coverage_fout);
          ___coverage_array[4254] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4260] == 0) {
    {
    fprintf(_coverage_fout, "4260\n");
    fflush(_coverage_fout);
    ___coverage_array[4260] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_hash_find((HashTable const   *)ht, arKey, nKeyLength, pData);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4261] == 0) {
    {
    fprintf(_coverage_fout, "4261\n");
    fflush(_coverage_fout);
    ___coverage_array[4261] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4298] == 0) {
    {
    fprintf(_coverage_fout, "4298\n");
    fflush(_coverage_fout);
    ___coverage_array[4298] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4297] == 0) {
      {
      fprintf(_coverage_fout, "4297\n");
      fflush(_coverage_fout);
      ___coverage_array[4297] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4294] == 0) {
        {
        fprintf(_coverage_fout, "4294\n");
        fflush(_coverage_fout);
        ___coverage_array[4294] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4295] == 0) {
        {
        fprintf(_coverage_fout, "4295\n");
        fflush(_coverage_fout);
        ___coverage_array[4295] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4262] == 0) {
          {
          fprintf(_coverage_fout, "4262\n");
          fflush(_coverage_fout);
          ___coverage_array[4262] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4263] == 0) {
          {
          fprintf(_coverage_fout, "4263\n");
          fflush(_coverage_fout);
          ___coverage_array[4263] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4296] == 0) {
        {
        fprintf(_coverage_fout, "4296\n");
        fflush(_coverage_fout);
        ___coverage_array[4296] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4292] == 0) {
          {
          fprintf(_coverage_fout, "4292\n");
          fflush(_coverage_fout);
          ___coverage_array[4292] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4286] == 0) {
            {
            fprintf(_coverage_fout, "4286\n");
            fflush(_coverage_fout);
            ___coverage_array[4286] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4287] == 0) {
            {
            fprintf(_coverage_fout, "4287\n");
            fflush(_coverage_fout);
            ___coverage_array[4287] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4270] == 0) {
              {
              fprintf(_coverage_fout, "4270\n");
              fflush(_coverage_fout);
              ___coverage_array[4270] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4264] == 0) {
                {
                fprintf(_coverage_fout, "4264\n");
                fflush(_coverage_fout);
                ___coverage_array[4264] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4269] == 0) {
                {
                fprintf(_coverage_fout, "4269\n");
                fflush(_coverage_fout);
                ___coverage_array[4269] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4268] == 0) {
                  {
                  fprintf(_coverage_fout, "4268\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4268] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4266] == 0) {
                    {
                    fprintf(_coverage_fout, "4266\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4266] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4265] == 0) {
                      {
                      fprintf(_coverage_fout, "4265\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4265] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4267] == 0) {
                    {
                    fprintf(_coverage_fout, "4267\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4267] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4288] == 0) {
            {
            fprintf(_coverage_fout, "4288\n");
            fflush(_coverage_fout);
            ___coverage_array[4288] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4289] == 0) {
            {
            fprintf(_coverage_fout, "4289\n");
            fflush(_coverage_fout);
            ___coverage_array[4289] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4274] == 0) {
              {
              fprintf(_coverage_fout, "4274\n");
              fflush(_coverage_fout);
              ___coverage_array[4274] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4275] == 0) {
              {
              fprintf(_coverage_fout, "4275\n");
              fflush(_coverage_fout);
              ___coverage_array[4275] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4273] == 0) {
                {
                fprintf(_coverage_fout, "4273\n");
                fflush(_coverage_fout);
                ___coverage_array[4273] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4272] == 0) {
                  {
                  fprintf(_coverage_fout, "4272\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4272] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4271] == 0) {
                    {
                    fprintf(_coverage_fout, "4271\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4271] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4276] == 0) {
              {
              fprintf(_coverage_fout, "4276\n");
              fflush(_coverage_fout);
              ___coverage_array[4276] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4290] == 0) {
            {
            fprintf(_coverage_fout, "4290\n");
            fflush(_coverage_fout);
            ___coverage_array[4290] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4282] == 0) {
              {
              fprintf(_coverage_fout, "4282\n");
              fflush(_coverage_fout);
              ___coverage_array[4282] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4278] == 0) {
                {
                fprintf(_coverage_fout, "4278\n");
                fflush(_coverage_fout);
                ___coverage_array[4278] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4277] == 0) {
                  {
                  fprintf(_coverage_fout, "4277\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4277] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4279] == 0) {
                {
                fprintf(_coverage_fout, "4279\n");
                fflush(_coverage_fout);
                ___coverage_array[4279] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4281] == 0) {
                {
                fprintf(_coverage_fout, "4281\n");
                fflush(_coverage_fout);
                ___coverage_array[4281] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4280] == 0) {
                  {
                  fprintf(_coverage_fout, "4280\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4280] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4283] == 0) {
              {
              fprintf(_coverage_fout, "4283\n");
              fflush(_coverage_fout);
              ___coverage_array[4283] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___0 = zend_hash_index_exists((HashTable const   *)ht, idx);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4284] == 0) {
              {
              fprintf(_coverage_fout, "4284\n");
              fflush(_coverage_fout);
              ___coverage_array[4284] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4285] == 0) {
              {
              fprintf(_coverage_fout, "4285\n");
              fflush(_coverage_fout);
              ___coverage_array[4285] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4291] == 0) {
            {
            fprintf(_coverage_fout, "4291\n");
            fflush(_coverage_fout);
            ___coverage_array[4291] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4293] == 0) {
          {
          fprintf(_coverage_fout, "4293\n");
          fflush(_coverage_fout);
          ___coverage_array[4293] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4299] == 0) {
    {
    fprintf(_coverage_fout, "4299\n");
    fflush(_coverage_fout);
    ___coverage_array[4299] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_hash_exists((HashTable const   *)ht, arKey, nKeyLength);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4300] == 0) {
    {
    fprintf(_coverage_fout, "4300\n");
    fflush(_coverage_fout);
    ___coverage_array[4300] = 1;
    }
  }
  fclose(_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 ) 
{ ulong idx ;
  register char const   *tmp ;
  char const   *end ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4337] == 0) {
    {
    fprintf(_coverage_fout, "4337\n");
    fflush(_coverage_fout);
    ___coverage_array[4337] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4336] == 0) {
      {
      fprintf(_coverage_fout, "4336\n");
      fflush(_coverage_fout);
      ___coverage_array[4336] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4333] == 0) {
        {
        fprintf(_coverage_fout, "4333\n");
        fflush(_coverage_fout);
        ___coverage_array[4333] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4334] == 0) {
        {
        fprintf(_coverage_fout, "4334\n");
        fflush(_coverage_fout);
        ___coverage_array[4334] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4301] == 0) {
          {
          fprintf(_coverage_fout, "4301\n");
          fflush(_coverage_fout);
          ___coverage_array[4301] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4302] == 0) {
          {
          fprintf(_coverage_fout, "4302\n");
          fflush(_coverage_fout);
          ___coverage_array[4302] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4335] == 0) {
        {
        fprintf(_coverage_fout, "4335\n");
        fflush(_coverage_fout);
        ___coverage_array[4335] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4331] == 0) {
          {
          fprintf(_coverage_fout, "4331\n");
          fflush(_coverage_fout);
          ___coverage_array[4331] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4325] == 0) {
            {
            fprintf(_coverage_fout, "4325\n");
            fflush(_coverage_fout);
            ___coverage_array[4325] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4326] == 0) {
            {
            fprintf(_coverage_fout, "4326\n");
            fflush(_coverage_fout);
            ___coverage_array[4326] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4309] == 0) {
              {
              fprintf(_coverage_fout, "4309\n");
              fflush(_coverage_fout);
              ___coverage_array[4309] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4303] == 0) {
                {
                fprintf(_coverage_fout, "4303\n");
                fflush(_coverage_fout);
                ___coverage_array[4303] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4308] == 0) {
                {
                fprintf(_coverage_fout, "4308\n");
                fflush(_coverage_fout);
                ___coverage_array[4308] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4307] == 0) {
                  {
                  fprintf(_coverage_fout, "4307\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4307] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4305] == 0) {
                    {
                    fprintf(_coverage_fout, "4305\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4305] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4304] == 0) {
                      {
                      fprintf(_coverage_fout, "4304\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4304] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4306] == 0) {
                    {
                    fprintf(_coverage_fout, "4306\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4306] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4327] == 0) {
            {
            fprintf(_coverage_fout, "4327\n");
            fflush(_coverage_fout);
            ___coverage_array[4327] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4328] == 0) {
            {
            fprintf(_coverage_fout, "4328\n");
            fflush(_coverage_fout);
            ___coverage_array[4328] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4313] == 0) {
              {
              fprintf(_coverage_fout, "4313\n");
              fflush(_coverage_fout);
              ___coverage_array[4313] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4314] == 0) {
              {
              fprintf(_coverage_fout, "4314\n");
              fflush(_coverage_fout);
              ___coverage_array[4314] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4312] == 0) {
                {
                fprintf(_coverage_fout, "4312\n");
                fflush(_coverage_fout);
                ___coverage_array[4312] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4311] == 0) {
                  {
                  fprintf(_coverage_fout, "4311\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4311] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4310] == 0) {
                    {
                    fprintf(_coverage_fout, "4310\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4310] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4315] == 0) {
              {
              fprintf(_coverage_fout, "4315\n");
              fflush(_coverage_fout);
              ___coverage_array[4315] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4329] == 0) {
            {
            fprintf(_coverage_fout, "4329\n");
            fflush(_coverage_fout);
            ___coverage_array[4329] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4321] == 0) {
              {
              fprintf(_coverage_fout, "4321\n");
              fflush(_coverage_fout);
              ___coverage_array[4321] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4317] == 0) {
                {
                fprintf(_coverage_fout, "4317\n");
                fflush(_coverage_fout);
                ___coverage_array[4317] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4316] == 0) {
                  {
                  fprintf(_coverage_fout, "4316\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4316] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4318] == 0) {
                {
                fprintf(_coverage_fout, "4318\n");
                fflush(_coverage_fout);
                ___coverage_array[4318] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4320] == 0) {
                {
                fprintf(_coverage_fout, "4320\n");
                fflush(_coverage_fout);
                ___coverage_array[4320] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4319] == 0) {
                  {
                  fprintf(_coverage_fout, "4319\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4319] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4322] == 0) {
              {
              fprintf(_coverage_fout, "4322\n");
              fflush(_coverage_fout);
              ___coverage_array[4322] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___0 = zend_hash_update_current_key_ex(ht, 2,
                                                      (char const   *)((void *)0),
                                                      0U, idx, mode, pos);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4323] == 0) {
              {
              fprintf(_coverage_fout, "4323\n");
              fflush(_coverage_fout);
              ___coverage_array[4323] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4324] == 0) {
              {
              fprintf(_coverage_fout, "4324\n");
              fflush(_coverage_fout);
              ___coverage_array[4324] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4330] == 0) {
            {
            fprintf(_coverage_fout, "4330\n");
            fflush(_coverage_fout);
            ___coverage_array[4330] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4332] == 0) {
          {
          fprintf(_coverage_fout, "4332\n");
          fflush(_coverage_fout);
          ___coverage_array[4332] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4338] == 0) {
    {
    fprintf(_coverage_fout, "4338\n");
    fflush(_coverage_fout);
    ___coverage_array[4338] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_hash_update_current_key_ex(ht, 1, arKey, nKeyLength, 0UL, mode,
                                            pos);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4339] == 0) {
    {
    fprintf(_coverage_fout, "4339\n");
    fflush(_coverage_fout);
    ___coverage_array[4339] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___1);
}
}
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 ) ;
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 void __attribute__((__visibility__("default")))  zend_ts_hash_destroy(TsHashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_clean(TsHashTable *ht ) ;
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 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_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_add_empty_element(TsHashTable *ht ,
                                                                                      char *arKey ,
                                                                                      uint nKeyLength ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_graceful_destroy(TsHashTable *ht ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_apply(TsHashTable *ht ,
                                                                           int (*apply_func)(void *pDest ) ) ;
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_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_reverse_apply(TsHashTable *ht ,
                                                                                   int (*apply_func)(void *pDest ) ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_del_key_or_index(TsHashTable *ht ,
                                                                                     char *arKey ,
                                                                                     uint nKeyLength ,
                                                                                     ulong h ,
                                                                                     int flag ) ;
extern ulong __attribute__((__visibility__("default")))  zend_ts_get_hash_value(TsHashTable *ht ,
                                                                                char *arKey ,
                                                                                uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_find(TsHashTable *ht ,
                                                                         char *arKey ,
                                                                         uint nKeyLength ,
                                                                         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_index_find(TsHashTable *ht ,
                                                                               ulong h ,
                                                                               void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_exists(TsHashTable *ht ,
                                                                           char *arKey ,
                                                                           uint nKeyLength ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_index_exists(TsHashTable *ht ,
                                                                                 ulong h ) ;
extern void __attribute__((__visibility__("default")))  zend_ts_hash_copy(TsHashTable *target ,
                                                                          TsHashTable *source ,
                                                                          void (*pCopyConstructor)(void *pElement ) ,
                                                                          void *tmp ,
                                                                          uint size ) ;
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_merge(TsHashTable *target ,
                                                                           TsHashTable *source ,
                                                                           void (*pCopyConstructor)(void *pElement ) ,
                                                                           void *tmp ,
                                                                           uint size ,
                                                                           int overwrite ) ;
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 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 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_minmax(TsHashTable *ht ,
                                                                           int (*compar)(void const   * ,
                                                                                         void const   * ) ,
                                                                           int flag ,
                                                                           void **pData ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_num_elements(TsHashTable *ht ) ;
extern int __attribute__((__visibility__("default")))  zend_ts_hash_rehash(TsHashTable *ht ) ;
extern ulong __attribute__((__visibility__("default")))  zend_ts_hash_func(char *arKey ,
                                                                           uint nKeyLength ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_init(zend_llist *l ,
                                                                        size_t size ,
                                                                        void (*dtor)(void * ) ,
                                                                        unsigned char persistent ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_add_element(zend_llist *l ,
                                                                               void *element ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_prepend_element(zend_llist *l ,
                                                                                   void *element ) ;
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_destroy(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_clean(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_remove_tail(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_copy(zend_llist *dst ,
                                                                        zend_llist *src ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_apply(zend_llist *l ,
                                                                         void (*func)(void * ) ) ;
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_with_argument(zend_llist *l ,
                                                                                       void (*func)(void *data ,
                                                                                                    void *arg ) ,
                                                                                       void *arg ) ;
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 int __attribute__((__visibility__("default")))  zend_llist_count(zend_llist *l ) ;
extern void __attribute__((__visibility__("default")))  zend_llist_sort(zend_llist *l ,
                                                                        int (*comp_func)(zend_llist_element const   ** ,
                                                                                         zend_llist_element const   ** ) ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_get_first_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_next_ex(zend_llist *l ,
                                                                                zend_llist_position *pos ) ;
extern void __attribute__((__visibility__("default")))  *zend_llist_get_prev_ex(zend_llist *l ,
                                                                                zend_llist_position *pos ) ;
extern  __attribute__((__noreturn__)) void zend_error_noreturn(int type ,
                                                               char const   *format 
                                                               , ...) ;
struct _zend_object_handlers  __attribute__((__visibility__("default"))) std_object_handlers ;
union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_static_method(zend_class_entry *ce ,
                                                                                             char const   *function_name_strval ,
                                                                                             int function_name_strlen ,
                                                                                             struct _zend_literal  const  *key ) ;
zval __attribute__((__visibility__("default")))  **zend_std_get_static_property(zend_class_entry *ce ,
                                                                                char const   *property_name ,
                                                                                int property_name_len ,
                                                                                zend_bool silent ,
                                                                                struct _zend_literal  const  *key ) ;
zend_bool __attribute__((__visibility__("default")))  zend_std_unset_static_property(zend_class_entry *ce ,
                                                                                     char const   *property_name ,
                                                                                     int property_name_len ,
                                                                                     struct _zend_literal  const  *key ) ;
union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_constructor(zval *object ) ;
struct _zend_property_info  __attribute__((__visibility__("default"))) *zend_get_property_info(zend_class_entry *ce ,
                                                                                               zval *member ,
                                                                                               int silent ) ;
HashTable __attribute__((__visibility__("default")))  *zend_std_get_properties(zval *object ) ;
HashTable __attribute__((__visibility__("default")))  *zend_std_get_debug_info(zval *object ,
                                                                               int *is_temp ) ;
int __attribute__((__visibility__("default")))  zend_std_cast_object_tostring(zval *readobj ,
                                                                              zval *writeobj ,
                                                                              int type ) ;
void __attribute__((__visibility__("default")))  zend_std_write_property(zval *object ,
                                                                         zval *member ,
                                                                         zval *value ,
                                                                         struct _zend_literal  const  *key ) ;
void __attribute__((__visibility__("default")))  rebuild_object_properties(zend_object *zobj ) ;
int __attribute__((__visibility__("default")))  zend_check_private(union _zend_function *fbc ,
                                                                   zend_class_entry *ce ,
                                                                   char *function_name_strval ,
                                                                   int function_name_strlen ) ;
int __attribute__((__visibility__("default")))  zend_check_protected(zend_class_entry *ce ,
                                                                     zend_class_entry *scope ) ;
int __attribute__((__visibility__("default")))  zend_check_property_access(zend_object *zobj ,
                                                                           char const   *prop_info_name ,
                                                                           int prop_info_name_len ) ;
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 ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_refcount_p)(zval *pz ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4340] == 0) {
    {
    fprintf(_coverage_fout, "4340\n");
    fflush(_coverage_fout);
    ___coverage_array[4340] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (pz->refcount__gc);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_set_refcount_p)(zval *pz ,
                                                                                    zend_uint rc ) 
{ zend_uint tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4341] == 0) {
    {
    fprintf(_coverage_fout, "4341\n");
    fflush(_coverage_fout);
    ___coverage_array[4341] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = rc;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4342] == 0) {
    {
    fprintf(_coverage_fout, "4342\n");
    fflush(_coverage_fout);
    ___coverage_array[4342] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->refcount__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4343] == 0) {
    {
    fprintf(_coverage_fout, "4343\n");
    fflush(_coverage_fout);
    ___coverage_array[4343] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_addref_p)(zval *pz ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4344] == 0) {
    {
    fprintf(_coverage_fout, "4344\n");
    fflush(_coverage_fout);
    ___coverage_array[4344] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (pz->refcount__gc) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4345] == 0) {
    {
    fprintf(_coverage_fout, "4345\n");
    fflush(_coverage_fout);
    ___coverage_array[4345] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (pz->refcount__gc);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_delref_p)(zval *pz ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4346] == 0) {
    {
    fprintf(_coverage_fout, "4346\n");
    fflush(_coverage_fout);
    ___coverage_array[4346] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (pz->refcount__gc) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4347] == 0) {
    {
    fprintf(_coverage_fout, "4347\n");
    fflush(_coverage_fout);
    ___coverage_array[4347] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (pz->refcount__gc);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_isref_p)(zval *pz ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4348] == 0) {
    {
    fprintf(_coverage_fout, "4348\n");
    fflush(_coverage_fout);
    ___coverage_array[4348] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (pz->is_ref__gc);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_p)(zval *pz ) 
{ zend_uchar tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4349] == 0) {
    {
    fprintf(_coverage_fout, "4349\n");
    fflush(_coverage_fout);
    ___coverage_array[4349] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4350] == 0) {
    {
    fprintf(_coverage_fout, "4350\n");
    fflush(_coverage_fout);
    ___coverage_array[4350] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4351] == 0) {
    {
    fprintf(_coverage_fout, "4351\n");
    fflush(_coverage_fout);
    ___coverage_array[4351] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_unset_isref_p)(zval *pz ) 
{ zend_uchar tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4352] == 0) {
    {
    fprintf(_coverage_fout, "4352\n");
    fflush(_coverage_fout);
    ___coverage_array[4352] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4353] == 0) {
    {
    fprintf(_coverage_fout, "4353\n");
    fflush(_coverage_fout);
    ___coverage_array[4353] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4354] == 0) {
    {
    fprintf(_coverage_fout, "4354\n");
    fflush(_coverage_fout);
    ___coverage_array[4354] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_to_p)(zval *pz ,
                                                                                    zend_bool isref ) 
{ zend_uchar tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4355] == 0) {
    {
    fprintf(_coverage_fout, "4355\n");
    fflush(_coverage_fout);
    ___coverage_array[4355] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = isref;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4356] == 0) {
    {
    fprintf(_coverage_fout, "4356\n");
    fflush(_coverage_fout);
    ___coverage_array[4356] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4357] == 0) {
    {
    fprintf(_coverage_fout, "4357\n");
    fflush(_coverage_fout);
    ___coverage_array[4357] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern enum zend_object_iterator_kind  __attribute__((__visibility__("default"))) zend_iterator_unwrap(zval *array_ptr ,
                                                                                                       zend_object_iterator **iter ) ;
extern zval __attribute__((__visibility__("default")))  *zend_iterator_wrap(zend_object_iterator *iter ) ;
extern void __attribute__((__visibility__("default")))  zend_register_iterator_wrapper(void) ;
extern int __attribute__((__visibility__("default")))  zend_stream_open(char const   *filename ,
                                                                        zend_file_handle *handle ) ;
extern int __attribute__((__visibility__("default")))  zend_stream_fixup(zend_file_handle *file_handle ,
                                                                         char **buf ,
                                                                         size_t *len ) ;
extern void __attribute__((__visibility__("default")))  zend_file_handle_dtor(zend_file_handle *fh ) ;
extern int __attribute__((__visibility__("default")))  zend_compare_file_handles(zend_file_handle *fh1 ,
                                                                                 zend_file_handle *fh2 ) ;
extern int zend_startup(zend_utility_functions *utility_functions ,
                        char **extensions ) ;
extern void zend_shutdown(void) ;
extern void zend_register_standard_ini_entries(void) ;
extern void zend_post_startup(void) ;
extern void zend_set_utility_values(zend_utility_values *utility_values ) ;
extern void __attribute__((__visibility__("default")))  _zend_bailout(char *filename ,
                                                                      uint lineno ) ;
extern char __attribute__((__visibility__("default")))  *get_zend_version(void) ;
extern void __attribute__((__visibility__("default")))  zend_make_printable_zval(zval *expr ,
                                                                                 zval *expr_copy ,
                                                                                 int *use_copy ) ;
extern int __attribute__((__visibility__("default")))  zend_print_zval(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 void __attribute__((__visibility__("default")))  zend_print_zval_r(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_ex(int (*write_func)(char const   *str ,
                                                                                               uint str_length ) ,
                                                                             zval *expr ,
                                                                             int indent ) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  zend_output_debug_string)(zend_bool trigger_break ,
                                                                                                            char const   *format 
                                                                                                            , ...) ;
extern void zend_activate(void) ;
extern void zend_deactivate(void) ;
extern void zend_call_destructors(void) ;
extern void zend_activate_modules(void) ;
extern void zend_deactivate_modules(void) ;
extern void zend_post_deactivate_modules(void) ;
extern void __attribute__((__visibility__("default")))  free_estring(char **str_p ) ;
extern int __attribute__((__visibility__("default")))  ( /* format attribute */  (*zend_printf))(char const   *format 
                                                                                                 , ...) ;
extern int (* __attribute__((__visibility__("default"))) zend_write)(char const   *str ,
                                                                     uint str_length ) ;
extern FILE __attribute__((__visibility__("default")))  *(*zend_fopen)(char const   *filename ,
                                                                       char **opened_path ) ;
extern void __attribute__((__visibility__("default")))  (*zend_ticks_function)(int ticks ) ;
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 (*zend_on_timeout)(int seconds ) ;
extern int __attribute__((__visibility__("default")))  (*zend_stream_open_function)(char const   *filename ,
                                                                                    zend_file_handle *handle ) ;
extern int (*zend_vspprintf)(char **pbuf , size_t max_len ,
                             char const   *format , va_list ap ) ;
extern char __attribute__((__visibility__("default")))  *(*zend_getenv)(char *name ,
                                                                        size_t name_len ) ;
extern char __attribute__((__visibility__("default")))  *(*zend_resolve_path)(char const   *filename ,
                                                                              int filename_len ) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  zend_error)(int type ,
                                                                                              char const   *format 
                                                                                              , ...) ;
extern void zenderror(char const   *error ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_standard_class_def ;
extern zend_utility_values __attribute__((__visibility__("default")))  zend_uv ;
extern zval __attribute__((__visibility__("default")))  zval_used_for_init ;
__inline extern int __sigismember(__sigset_t const   *__set , int __sig ) ;
__inline extern int __sigaddset(__sigset_t *__set , int __sig ) ;
__inline extern int __sigdelset(__sigset_t *__set , int __sig ) ;
__inline extern int __sigismember(__sigset_t const   *__set , int __sig ) 
{ unsigned long __mask ;
  unsigned long __word ;
  int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4360] == 0) {
    {
    fprintf(_coverage_fout, "4360\n");
    fflush(_coverage_fout);
    ___coverage_array[4360] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __mask = 1UL << (unsigned int )(__sig - 1) % (8U * sizeof(unsigned long ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4361] == 0) {
    {
    fprintf(_coverage_fout, "4361\n");
    fflush(_coverage_fout);
    ___coverage_array[4361] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __word = (unsigned long )((unsigned int )(__sig - 1) / (8U * sizeof(unsigned long )));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4362] == 0) {
    {
    fprintf(_coverage_fout, "4362\n");
    fflush(_coverage_fout);
    ___coverage_array[4362] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__set->__val[__word] & __mask) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4358] == 0) {
      {
      fprintf(_coverage_fout, "4358\n");
      fflush(_coverage_fout);
      ___coverage_array[4358] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4359] == 0) {
      {
      fprintf(_coverage_fout, "4359\n");
      fflush(_coverage_fout);
      ___coverage_array[4359] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = 0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4363] == 0) {
    {
    fprintf(_coverage_fout, "4363\n");
    fflush(_coverage_fout);
    ___coverage_array[4363] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int __sigaddset(__sigset_t *__set , int __sig ) 
{ unsigned long __mask ;
  unsigned long __word ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4364] == 0) {
    {
    fprintf(_coverage_fout, "4364\n");
    fflush(_coverage_fout);
    ___coverage_array[4364] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __mask = 1UL << (unsigned int )(__sig - 1) % (8U * sizeof(unsigned long ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4365] == 0) {
    {
    fprintf(_coverage_fout, "4365\n");
    fflush(_coverage_fout);
    ___coverage_array[4365] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __word = (unsigned long )((unsigned int )(__sig - 1) / (8U * sizeof(unsigned long )));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4366] == 0) {
    {
    fprintf(_coverage_fout, "4366\n");
    fflush(_coverage_fout);
    ___coverage_array[4366] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __set->__val[__word] |= __mask;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4367] == 0) {
    {
    fprintf(_coverage_fout, "4367\n");
    fflush(_coverage_fout);
    ___coverage_array[4367] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
__inline extern int __sigdelset(__sigset_t *__set , int __sig ) 
{ unsigned long __mask ;
  unsigned long __word ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4368] == 0) {
    {
    fprintf(_coverage_fout, "4368\n");
    fflush(_coverage_fout);
    ___coverage_array[4368] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __mask = 1UL << (unsigned int )(__sig - 1) % (8U * sizeof(unsigned long ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4369] == 0) {
    {
    fprintf(_coverage_fout, "4369\n");
    fflush(_coverage_fout);
    ___coverage_array[4369] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __word = (unsigned long )((unsigned int )(__sig - 1) / (8U * sizeof(unsigned long )));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4370] == 0) {
    {
    fprintf(_coverage_fout, "4370\n");
    fflush(_coverage_fout);
    ___coverage_array[4370] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __set->__val[__word] &= ~ __mask;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4371] == 0) {
    {
    fprintf(_coverage_fout, "4371\n");
    fflush(_coverage_fout);
    ___coverage_array[4371] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
extern  __attribute__((__nothrow__)) __sighandler_t __sysv_signal(int __sig ,
                                                                  void (*__handler)(int  ) ) ;
extern  __attribute__((__nothrow__)) __sighandler_t sysv_signal(int __sig ,
                                                                void (*__handler)(int  ) ) ;
extern  __attribute__((__nothrow__)) __sighandler_t signal(int __sig ,
                                                           void (*__handler)(int  ) ) ;
extern  __attribute__((__nothrow__)) __sighandler_t bsd_signal(int __sig ,
                                                               void (*__handler)(int  ) ) ;
extern  __attribute__((__nothrow__)) int kill(__pid_t __pid , int __sig ) ;
extern  __attribute__((__nothrow__)) int killpg(__pid_t __pgrp , int __sig ) ;
extern  __attribute__((__nothrow__)) int raise(int __sig ) ;
extern  __attribute__((__nothrow__)) __sighandler_t ssignal(int __sig ,
                                                            void (*__handler)(int  ) ) ;
extern  __attribute__((__nothrow__)) int gsignal(int __sig ) ;
extern void psignal(int __sig , char const   *__s ) ;
extern void psiginfo(siginfo_t const   *__pinfo , char const   *__s ) ;
extern int __sigpause(int __sig_or_mask , int __is_sig ) ;
extern int sigpause(int __sig )  __asm__("__xpg_sigpause")  ;
extern  __attribute__((__nothrow__)) int sigblock(int __mask )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int sigsetmask(int __mask )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int siggetmask(void)  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int sigemptyset(sigset_t *__set )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigfillset(sigset_t *__set )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigaddset(sigset_t *__set ,
                                                   int __signo )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigdelset(sigset_t *__set ,
                                                   int __signo )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigismember(sigset_t const   *__set ,
                                                     int __signo )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigisemptyset(sigset_t const   *__set )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigandset(sigset_t *__set ,
                                                   sigset_t const   *__left ,
                                                   sigset_t const   *__right )  __attribute__((__nonnull__(1,2,3))) ;
extern  __attribute__((__nothrow__)) int sigorset(sigset_t *__set ,
                                                  sigset_t const   *__left ,
                                                  sigset_t const   *__right )  __attribute__((__nonnull__(1,2,3))) ;
extern  __attribute__((__nothrow__)) int sigprocmask(int __how ,
                                                     sigset_t const   * __restrict  __set ,
                                                     sigset_t * __restrict  __oset ) ;
extern int sigsuspend(sigset_t const   *__set )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigaction(int __sig ,
                                                   struct sigaction  const  * __restrict  __act ,
                                                   struct sigaction * __restrict  __oact ) ;
extern  __attribute__((__nothrow__)) int sigpending(sigset_t *__set )  __attribute__((__nonnull__(1))) ;
extern int sigwait(sigset_t const   * __restrict  __set ,
                   int * __restrict  __sig )  __attribute__((__nonnull__(1,2))) ;
extern int sigwaitinfo(sigset_t const   * __restrict  __set ,
                       siginfo_t * __restrict  __info )  __attribute__((__nonnull__(1))) ;
extern int sigtimedwait(sigset_t const   * __restrict  __set ,
                        siginfo_t * __restrict  __info ,
                        struct timespec  const  * __restrict  __timeout )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int sigqueue(__pid_t __pid , int __sig ,
                                                  union sigval __val ) ;
extern char const   * const  _sys_siglist[65] ;
extern char const   * const  sys_siglist[65] ;
extern  __attribute__((__nothrow__)) int sigvec(int __sig ,
                                                struct sigvec  const  *__vec ,
                                                struct sigvec *__ovec ) ;
extern  __attribute__((__nothrow__)) int sigreturn(struct sigcontext *__scp ) ;
extern  __attribute__((__nothrow__)) int siginterrupt(int __sig ,
                                                      int __interrupt ) ;
extern  __attribute__((__nothrow__)) int sigstack(struct sigstack *__ss ,
                                                  struct sigstack *__oss )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int sigaltstack(struct sigaltstack  const  * __restrict  __ss ,
                                                     struct sigaltstack * __restrict  __oss ) ;
extern  __attribute__((__nothrow__)) int sighold(int __sig ) ;
extern  __attribute__((__nothrow__)) int sigrelse(int __sig ) ;
extern  __attribute__((__nothrow__)) int sigignore(int __sig ) ;
extern  __attribute__((__nothrow__)) __sighandler_t sigset(int __sig ,
                                                           void (*__disp)(int  ) ) ;
extern  __attribute__((__nothrow__)) int pthread_sigmask(int __how ,
                                                         __sigset_t const   * __restrict  __newmask ,
                                                         __sigset_t * __restrict  __oldmask ) ;
extern  __attribute__((__nothrow__)) int pthread_kill(pthread_t __threadid ,
                                                      int __signo ) ;
extern  __attribute__((__nothrow__)) int pthread_sigqueue(pthread_t __threadid ,
                                                          int __signo ,
                                                          union sigval __value ) ;
extern  __attribute__((__nothrow__)) int __libc_current_sigrtmin(void) ;
extern  __attribute__((__nothrow__)) int __libc_current_sigrtmax(void) ;
extern zend_signal_globals_t __attribute__((__visibility__("default")))  zend_signal_globals ;
extern void zend_signal_handler_defer(int signo , siginfo_t *siginfo ,
                                      void *context ) ;
extern void zend_signal_handler_unblock() ;
extern void zend_signal_activate(void) ;
extern void zend_signal_deactivate(void) ;
extern void zend_signal_startup() ;
extern void zend_signal_shutdown(void) ;
extern int __attribute__((__visibility__("default")))  zend_signal(int signo ,
                                                                   void (*handler)(int  ) ) ;
extern int __attribute__((__visibility__("default")))  zend_sigaction(int signo ,
                                                                      struct sigaction  const  *act ,
                                                                      struct sigaction *oldact ) ;
extern void __attribute__((__visibility__("default")))  zend_message_dispatcher(long message ,
                                                                                void const   *data ) ;
extern int __attribute__((__visibility__("default")))  zend_get_configuration_directive(char const   *name ,
                                                                                        uint name_length ,
                                                                                        zval *contents ) ;
extern zend_gc_globals __attribute__((__visibility__("default")))  gc_globals ;
extern int __attribute__((__visibility__("default")))  gc_collect_cycles(void) ;
extern void __attribute__((__visibility__("default")))  gc_zval_possible_root(zval *zv ) ;
extern void __attribute__((__visibility__("default")))  gc_zobj_possible_root(zval *zv ) ;
extern void __attribute__((__visibility__("default")))  gc_remove_zval_from_buffer(zval *zv ) ;
extern void __attribute__((__visibility__("default")))  gc_globals_ctor(void) ;
extern void __attribute__((__visibility__("default")))  gc_globals_dtor(void) ;
extern void __attribute__((__visibility__("default")))  gc_init(void) ;
extern void __attribute__((__visibility__("default")))  gc_reset(void) ;
__inline static void ( __attribute__((__always_inline__)) gc_zval_check_possible_root)(zval *z ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4376] == 0) {
    {
    fprintf(_coverage_fout, "4376\n");
    fflush(_coverage_fout);
    ___coverage_array[4376] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )z->type == 4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4372] == 0) {
      {
      fprintf(_coverage_fout, "4372\n");
      fflush(_coverage_fout);
      ___coverage_array[4372] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    gc_zval_possible_root(z);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4375] == 0) {
      {
      fprintf(_coverage_fout, "4375\n");
      fflush(_coverage_fout);
      ___coverage_array[4375] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )z->type == 5) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4373] == 0) {
        {
        fprintf(_coverage_fout, "4373\n");
        fflush(_coverage_fout);
        ___coverage_array[4373] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      gc_zval_possible_root(z);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4374] == 0) {
        {
        fprintf(_coverage_fout, "4374\n");
        fflush(_coverage_fout);
        ___coverage_array[4374] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4377] == 0) {
    {
    fprintf(_coverage_fout, "4377\n");
    fflush(_coverage_fout);
    ___coverage_array[4377] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) gc_remove_from_buffer)(gc_root_buffer *root ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4378] == 0) {
    {
    fprintf(_coverage_fout, "4378\n");
    fflush(_coverage_fout);
    ___coverage_array[4378] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (root->next)->prev = root->prev;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4379] == 0) {
    {
    fprintf(_coverage_fout, "4379\n");
    fflush(_coverage_fout);
    ___coverage_array[4379] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (root->prev)->next = root->next;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4380] == 0) {
    {
    fprintf(_coverage_fout, "4380\n");
    fflush(_coverage_fout);
    ___coverage_array[4380] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  root->prev = gc_globals.unused;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4381] == 0) {
    {
    fprintf(_coverage_fout, "4381\n");
    fflush(_coverage_fout);
    ___coverage_array[4381] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  gc_globals.unused = root;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4382] == 0) {
    {
    fprintf(_coverage_fout, "4382\n");
    fflush(_coverage_fout);
    ___coverage_array[4382] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
extern  __attribute__((__nothrow__)) int *__errno_location(void)  __attribute__((__const__)) ;
extern char *program_invocation_name ;
extern char *program_invocation_short_name ;
extern  __attribute__((__nothrow__,
__noreturn__)) void __assert_fail(char const   *__assertion ,
                                  char const   *__file , unsigned int __line ,
                                  char const   *__function ) ;
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(char const   *__assertion , char const   *__file ,
                             int __line ) ;
extern void __attribute__((__visibility__("default")))  zend_freedtoa(char *s ) ;
extern char __attribute__((__visibility__("default")))  *zend_dtoa(double _d ,
                                                                   int mode ,
                                                                   int ndigits ,
                                                                   int *decpt ,
                                                                   int *sign ,
                                                                   char **rve ) ;
extern double __attribute__((__visibility__("default")))  zend_strtod(char const   *s00 ,
                                                                      char const   **se ) ;
extern double __attribute__((__visibility__("default")))  zend_hex_strtod(char const   *str ,
                                                                          char const   **endptr ) ;
extern double __attribute__((__visibility__("default")))  zend_oct_strtod(char const   *str ,
                                                                          char const   **endptr ) ;
extern double __attribute__((__visibility__("default")))  zend_bin_strtod(char const   *str ,
                                                                          char const   **endptr ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_strtod(void) ;
extern int __attribute__((__visibility__("default")))  zend_shutdown_strtod(void) ;
extern int __attribute__((__visibility__("default")))  add_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")))  mul_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")))  mod_function(zval *result ,
                                                                    zval *op1 ,
                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  boolean_xor_function(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  boolean_not_function(zval *result ,
                                                                            zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_not_function(zval *result ,
                                                                            zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_or_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_xor_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")))  shift_right_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")))  is_equal_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_not_identical_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_smaller_function(zval *result ,
                                                                           zval *op1 ,
                                                                           zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_smaller_or_equal_function(zval *result ,
                                                                                    zval *op1 ,
                                                                                    zval *op2 ) ;
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 zend_bool __attribute__((__visibility__("default")))  instanceof_function(zend_class_entry const   *instance_ce ,
                                                                                 zend_class_entry const   *ce ) ;
__inline static long ( __attribute__((__always_inline__)) zend_dval_to_lval)(double d ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4387] == 0) {
    {
    fprintf(_coverage_fout, "4387\n");
    fflush(_coverage_fout);
    ___coverage_array[4387] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (d > (double )2147483647L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4383] == 0) {
      {
      fprintf(_coverage_fout, "4383\n");
      fflush(_coverage_fout);
      ___coverage_array[4383] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((long )((unsigned long )((long long )d)));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4386] == 0) {
      {
      fprintf(_coverage_fout, "4386\n");
      fflush(_coverage_fout);
      ___coverage_array[4386] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (d < (double )(-0x7FFFFFFF-1)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4384] == 0) {
        {
        fprintf(_coverage_fout, "4384\n");
        fflush(_coverage_fout);
        ___coverage_array[4384] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((long )((unsigned long )((long long )d)));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4385] == 0) {
        {
        fprintf(_coverage_fout, "4385\n");
        fflush(_coverage_fout);
        ___coverage_array[4385] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4388] == 0) {
    {
    fprintf(_coverage_fout, "4388\n");
    fflush(_coverage_fout);
    ___coverage_array[4388] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((long )d);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4543] == 0) {
    {
    fprintf(_coverage_fout, "4543\n");
    fflush(_coverage_fout);
    ___coverage_array[4543] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  base = 10;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4544] == 0) {
    {
    fprintf(_coverage_fout, "4544\n");
    fflush(_coverage_fout);
    ___coverage_array[4544] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  digits = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4545] == 0) {
    {
    fprintf(_coverage_fout, "4545\n");
    fflush(_coverage_fout);
    ___coverage_array[4545] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dp_or_e = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4546] == 0) {
    {
    fprintf(_coverage_fout, "4546\n");
    fflush(_coverage_fout);
    ___coverage_array[4546] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! length) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4389] == 0) {
      {
      fprintf(_coverage_fout, "4389\n");
      fflush(_coverage_fout);
      ___coverage_array[4389] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((unsigned char)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4390] == 0) {
      {
      fprintf(_coverage_fout, "4390\n");
      fflush(_coverage_fout);
      ___coverage_array[4390] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4547] == 0) {
    {
    fprintf(_coverage_fout, "4547\n");
    fflush(_coverage_fout);
    ___coverage_array[4547] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4402] == 0) {
      {
      fprintf(_coverage_fout, "4402\n");
      fflush(_coverage_fout);
      ___coverage_array[4402] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*str == 32) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4391] == 0) {
        {
        fprintf(_coverage_fout, "4391\n");
        fflush(_coverage_fout);
        ___coverage_array[4391] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4401] == 0) {
        {
        fprintf(_coverage_fout, "4401\n");
        fflush(_coverage_fout);
        ___coverage_array[4401] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*str == 9) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4392] == 0) {
          {
          fprintf(_coverage_fout, "4392\n");
          fflush(_coverage_fout);
          ___coverage_array[4392] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4400] == 0) {
          {
          fprintf(_coverage_fout, "4400\n");
          fflush(_coverage_fout);
          ___coverage_array[4400] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*str == 10) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4393] == 0) {
            {
            fprintf(_coverage_fout, "4393\n");
            fflush(_coverage_fout);
            ___coverage_array[4393] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4399] == 0) {
            {
            fprintf(_coverage_fout, "4399\n");
            fflush(_coverage_fout);
            ___coverage_array[4399] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*str == 13) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4394] == 0) {
              {
              fprintf(_coverage_fout, "4394\n");
              fflush(_coverage_fout);
              ___coverage_array[4394] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4398] == 0) {
              {
              fprintf(_coverage_fout, "4398\n");
              fflush(_coverage_fout);
              ___coverage_array[4398] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*str == 11) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4395] == 0) {
                {
                fprintf(_coverage_fout, "4395\n");
                fflush(_coverage_fout);
                ___coverage_array[4395] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4397] == 0) {
                {
                fprintf(_coverage_fout, "4397\n");
                fflush(_coverage_fout);
                ___coverage_array[4397] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*str == 12) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4396] == 0) {
                  {
                  fprintf(_coverage_fout, "4396\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4396] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              } else {
                break;
              }
            }
          }
        }
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4403] == 0) {
      {
      fprintf(_coverage_fout, "4403\n");
      fflush(_coverage_fout);
      ___coverage_array[4403] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    str ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4404] == 0) {
      {
      fprintf(_coverage_fout, "4404\n");
      fflush(_coverage_fout);
      ___coverage_array[4404] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length --;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4548] == 0) {
    {
    fprintf(_coverage_fout, "4548\n");
    fflush(_coverage_fout);
    ___coverage_array[4548] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ptr = str;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4549] == 0) {
    {
    fprintf(_coverage_fout, "4549\n");
    fflush(_coverage_fout);
    ___coverage_array[4549] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*ptr == 45) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4405] == 0) {
      {
      fprintf(_coverage_fout, "4405\n");
      fflush(_coverage_fout);
      ___coverage_array[4405] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ptr ++;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4408] == 0) {
      {
      fprintf(_coverage_fout, "4408\n");
      fflush(_coverage_fout);
      ___coverage_array[4408] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*ptr == 43) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4406] == 0) {
        {
        fprintf(_coverage_fout, "4406\n");
        fflush(_coverage_fout);
        ___coverage_array[4406] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ptr ++;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4407] == 0) {
        {
        fprintf(_coverage_fout, "4407\n");
        fflush(_coverage_fout);
        ___coverage_array[4407] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4550] == 0) {
    {
    fprintf(_coverage_fout, "4550\n");
    fflush(_coverage_fout);
    ___coverage_array[4550] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*ptr >= 48) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4477] == 0) {
      {
      fprintf(_coverage_fout, "4477\n");
      fflush(_coverage_fout);
      ___coverage_array[4477] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*ptr <= 57) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4472] == 0) {
        {
        fprintf(_coverage_fout, "4472\n");
        fflush(_coverage_fout);
        ___coverage_array[4472] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (length > 2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4417] == 0) {
          {
          fprintf(_coverage_fout, "4417\n");
          fflush(_coverage_fout);
          ___coverage_array[4417] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*str == 48) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4415] == 0) {
            {
            fprintf(_coverage_fout, "4415\n");
            fflush(_coverage_fout);
            ___coverage_array[4415] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*(str + 1) == 120) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4409] == 0) {
              {
              fprintf(_coverage_fout, "4409\n");
              fflush(_coverage_fout);
              ___coverage_array[4409] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            base = 16;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4410] == 0) {
              {
              fprintf(_coverage_fout, "4410\n");
              fflush(_coverage_fout);
              ___coverage_array[4410] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            ptr += 2;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4414] == 0) {
              {
              fprintf(_coverage_fout, "4414\n");
              fflush(_coverage_fout);
              ___coverage_array[4414] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*(str + 1) == 88) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4411] == 0) {
                {
                fprintf(_coverage_fout, "4411\n");
                fflush(_coverage_fout);
                ___coverage_array[4411] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              base = 16;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4412] == 0) {
                {
                fprintf(_coverage_fout, "4412\n");
                fflush(_coverage_fout);
                ___coverage_array[4412] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              ptr += 2;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4413] == 0) {
                {
                fprintf(_coverage_fout, "4413\n");
                fflush(_coverage_fout);
                ___coverage_array[4413] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4416] == 0) {
            {
            fprintf(_coverage_fout, "4416\n");
            fflush(_coverage_fout);
            ___coverage_array[4416] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4418] == 0) {
          {
          fprintf(_coverage_fout, "4418\n");
          fflush(_coverage_fout);
          ___coverage_array[4418] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4473] == 0) {
        {
        fprintf(_coverage_fout, "4473\n");
        fflush(_coverage_fout);
        ___coverage_array[4473] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4420] == 0) {
          {
          fprintf(_coverage_fout, "4420\n");
          fflush(_coverage_fout);
          ___coverage_array[4420] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*ptr == 48) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4419] == 0) {
            {
            fprintf(_coverage_fout, "4419\n");
            fflush(_coverage_fout);
            ___coverage_array[4419] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4421] == 0) {
          {
          fprintf(_coverage_fout, "4421\n");
          fflush(_coverage_fout);
          ___coverage_array[4421] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ptr ++;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4474] == 0) {
        {
        fprintf(_coverage_fout, "4474\n");
        fflush(_coverage_fout);
        ___coverage_array[4474] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      type = (unsigned char)1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4475] == 0) {
        {
        fprintf(_coverage_fout, "4475\n");
        fflush(_coverage_fout);
        ___coverage_array[4475] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4455] == 0) {
          {
          fprintf(_coverage_fout, "4455\n");
          fflush(_coverage_fout);
          ___coverage_array[4455] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (digits >= 11) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4424] == 0) {
            {
            fprintf(_coverage_fout, "4424\n");
            fflush(_coverage_fout);
            ___coverage_array[4424] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (dval) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4423] == 0) {
              {
              fprintf(_coverage_fout, "4423\n");
              fflush(_coverage_fout);
              ___coverage_array[4423] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (allow_errors == 1) {
              break;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4422] == 0) {
                {
                fprintf(_coverage_fout, "4422\n");
                fflush(_coverage_fout);
                ___coverage_array[4422] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4425] == 0) {
            {
            fprintf(_coverage_fout, "4425\n");
            fflush(_coverage_fout);
            ___coverage_array[4425] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4456] == 0) {
          {
          fprintf(_coverage_fout, "4456\n");
          fflush(_coverage_fout);
          ___coverage_array[4456] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        check_digits: 
        if ((int const   )*ptr >= 48) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4426] == 0) {
            {
            fprintf(_coverage_fout, "4426\n");
            fflush(_coverage_fout);
            ___coverage_array[4426] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*ptr <= 57) {
            goto __Cont;
          } else {
            goto _L___3;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4454] == 0) {
            {
            fprintf(_coverage_fout, "4454\n");
            fflush(_coverage_fout);
            ___coverage_array[4454] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___3: /* CIL Label */ 
          if (base == 16) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4430] == 0) {
              {
              fprintf(_coverage_fout, "4430\n");
              fflush(_coverage_fout);
              ___coverage_array[4430] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*ptr >= 65) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4427] == 0) {
                {
                fprintf(_coverage_fout, "4427\n");
                fflush(_coverage_fout);
                ___coverage_array[4427] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*ptr <= 70) {
                goto __Cont;
              } else {
                goto _L___2;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4429] == 0) {
                {
                fprintf(_coverage_fout, "4429\n");
                fflush(_coverage_fout);
                ___coverage_array[4429] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L___2: /* CIL Label */ 
              if ((int const   )*ptr >= 97) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4428] == 0) {
                  {
                  fprintf(_coverage_fout, "4428\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4428] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*ptr <= 102) {
                  goto __Cont;
                } else {
                  goto _L___1;
                }
              } else {
                goto _L___1;
              }
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4453] == 0) {
              {
              fprintf(_coverage_fout, "4453\n");
              fflush(_coverage_fout);
              ___coverage_array[4453] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _L___1: /* CIL Label */ 
            if (base == 10) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4451] == 0) {
                {
                fprintf(_coverage_fout, "4451\n");
                fflush(_coverage_fout);
                ___coverage_array[4451] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*ptr == 46) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4431] == 0) {
                  {
                  fprintf(_coverage_fout, "4431\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4431] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (dp_or_e < 1) {
                  goto process_double;
                } else {
                  goto _L___0;
                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4450] == 0) {
                  {
                  fprintf(_coverage_fout, "4450\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4450] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _L___0: /* CIL Label */ 
                if ((int const   )*ptr == 101) {
                  goto _L;
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4449] == 0) {
                    {
                    fprintf(_coverage_fout, "4449\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4449] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*ptr == 69) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4447] == 0) {
                      {
                      fprintf(_coverage_fout, "4447\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4447] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    _L: /* CIL Label */ 
                    if (dp_or_e < 2) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[4443] == 0) {
                        {
                        fprintf(_coverage_fout, "4443\n");
                        fflush(_coverage_fout);
                        ___coverage_array[4443] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      e = ptr + 1;
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[4444] == 0) {
                        {
                        fprintf(_coverage_fout, "4444\n");
                        fflush(_coverage_fout);
                        ___coverage_array[4444] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if ((int const   )*e == 45) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[4432] == 0) {
                          {
                          fprintf(_coverage_fout, "4432\n");
                          fflush(_coverage_fout);
                          ___coverage_array[4432] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        tmp = e;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[4433] == 0) {
                          {
                          fprintf(_coverage_fout, "4433\n");
                          fflush(_coverage_fout);
                          ___coverage_array[4433] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        e ++;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[4434] == 0) {
                          {
                          fprintf(_coverage_fout, "4434\n");
                          fflush(_coverage_fout);
                          ___coverage_array[4434] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        ptr = tmp;
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[4439] == 0) {
                          {
                          fprintf(_coverage_fout, "4439\n");
                          fflush(_coverage_fout);
                          ___coverage_array[4439] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        if ((int const   )*e == 43) {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[4435] == 0) {
                            {
                            fprintf(_coverage_fout, "4435\n");
                            fflush(_coverage_fout);
                            ___coverage_array[4435] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          tmp = e;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[4436] == 0) {
                            {
                            fprintf(_coverage_fout, "4436\n");
                            fflush(_coverage_fout);
                            ___coverage_array[4436] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          e ++;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[4437] == 0) {
                            {
                            fprintf(_coverage_fout, "4437\n");
                            fflush(_coverage_fout);
                            ___coverage_array[4437] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          ptr = tmp;
                        } else {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[4438] == 0) {
                            {
                            fprintf(_coverage_fout, "4438\n");
                            fflush(_coverage_fout);
                            ___coverage_array[4438] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }

                        }
                      }
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[4445] == 0) {
                        {
                        fprintf(_coverage_fout, "4445\n");
                        fflush(_coverage_fout);
                        ___coverage_array[4445] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if ((int const   )*e >= 48) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[4441] == 0) {
                          {
                          fprintf(_coverage_fout, "4441\n");
                          fflush(_coverage_fout);
                          ___coverage_array[4441] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        if ((int const   )*e <= 57) {
                          goto process_double;
                        } else {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[4440] == 0) {
                            {
                            fprintf(_coverage_fout, "4440\n");
                            fflush(_coverage_fout);
                            ___coverage_array[4440] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }

                        }
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[4442] == 0) {
                          {
                          fprintf(_coverage_fout, "4442\n");
                          fflush(_coverage_fout);
                          ___coverage_array[4442] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }

                      }
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[4446] == 0) {
                        {
                        fprintf(_coverage_fout, "4446\n");
                        fflush(_coverage_fout);
                        ___coverage_array[4446] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }

                    }
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[4448] == 0) {
                      {
                      fprintf(_coverage_fout, "4448\n");
                      fflush(_coverage_fout);
                      ___coverage_array[4448] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                }
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4452] == 0) {
                {
                fprintf(_coverage_fout, "4452\n");
                fflush(_coverage_fout);
                ___coverage_array[4452] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        }
        break;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4457] == 0) {
          {
          fprintf(_coverage_fout, "4457\n");
          fflush(_coverage_fout);
          ___coverage_array[4457] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __Cont: /* CIL Label */ 
        digits ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4458] == 0) {
          {
          fprintf(_coverage_fout, "4458\n");
          fflush(_coverage_fout);
          ___coverage_array[4458] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ptr ++;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4476] == 0) {
        {
        fprintf(_coverage_fout, "4476\n");
        fflush(_coverage_fout);
        ___coverage_array[4476] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (base == 10) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4461] == 0) {
          {
          fprintf(_coverage_fout, "4461\n");
          fflush(_coverage_fout);
          ___coverage_array[4461] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (digits >= 11) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4459] == 0) {
            {
            fprintf(_coverage_fout, "4459\n");
            fflush(_coverage_fout);
            ___coverage_array[4459] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          dp_or_e = -1;
          goto process_double;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4460] == 0) {
            {
            fprintf(_coverage_fout, "4460\n");
            fflush(_coverage_fout);
            ___coverage_array[4460] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4471] == 0) {
          {
          fprintf(_coverage_fout, "4471\n");
          fflush(_coverage_fout);
          ___coverage_array[4471] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (digits < 8) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4462] == 0) {
            {
            fprintf(_coverage_fout, "4462\n");
            fflush(_coverage_fout);
            ___coverage_array[4462] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4470] == 0) {
            {
            fprintf(_coverage_fout, "4470\n");
            fflush(_coverage_fout);
            ___coverage_array[4470] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (digits == 8) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4464] == 0) {
              {
              fprintf(_coverage_fout, "4464\n");
              fflush(_coverage_fout);
              ___coverage_array[4464] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*(ptr + - digits) <= 55) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4463] == 0) {
                {
                fprintf(_coverage_fout, "4463\n");
                fflush(_coverage_fout);
                ___coverage_array[4463] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            } else {
              goto _L___4;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4468] == 0) {
              {
              fprintf(_coverage_fout, "4468\n");
              fflush(_coverage_fout);
              ___coverage_array[4468] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _L___4: /* CIL Label */ 
            if (dval) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4465] == 0) {
                {
                fprintf(_coverage_fout, "4465\n");
                fflush(_coverage_fout);
                ___coverage_array[4465] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___0 = zend_hex_strtod(str, & ptr);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4466] == 0) {
                {
                fprintf(_coverage_fout, "4466\n");
                fflush(_coverage_fout);
                ___coverage_array[4466] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              local_dval = (double )tmp___0;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4467] == 0) {
                {
                fprintf(_coverage_fout, "4467\n");
                fflush(_coverage_fout);
                ___coverage_array[4467] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4469] == 0) {
              {
              fprintf(_coverage_fout, "4469\n");
              fflush(_coverage_fout);
              ___coverage_array[4469] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            type = (unsigned char)2;
          }
        }
      }
    } else {
      goto _L___5;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4496] == 0) {
      {
      fprintf(_coverage_fout, "4496\n");
      fflush(_coverage_fout);
      ___coverage_array[4496] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L___5: /* CIL Label */ 
    if ((int const   )*ptr == 46) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4494] == 0) {
        {
        fprintf(_coverage_fout, "4494\n");
        fflush(_coverage_fout);
        ___coverage_array[4494] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(ptr + 1) >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4492] == 0) {
          {
          fprintf(_coverage_fout, "4492\n");
          fflush(_coverage_fout);
          ___coverage_array[4492] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(ptr + 1) <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4489] == 0) {
            {
            fprintf(_coverage_fout, "4489\n");
            fflush(_coverage_fout);
            ___coverage_array[4489] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          process_double: 
          type = (unsigned char)2;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4490] == 0) {
            {
            fprintf(_coverage_fout, "4490\n");
            fflush(_coverage_fout);
            ___coverage_array[4490] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (dval) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4478] == 0) {
              {
              fprintf(_coverage_fout, "4478\n");
              fflush(_coverage_fout);
              ___coverage_array[4478] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___1 = zend_strtod(str, & ptr);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4479] == 0) {
              {
              fprintf(_coverage_fout, "4479\n");
              fflush(_coverage_fout);
              ___coverage_array[4479] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            local_dval = (double )tmp___1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4488] == 0) {
              {
              fprintf(_coverage_fout, "4488\n");
              fflush(_coverage_fout);
              ___coverage_array[4488] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (allow_errors != 1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4486] == 0) {
                {
                fprintf(_coverage_fout, "4486\n");
                fflush(_coverage_fout);
                ___coverage_array[4486] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (dp_or_e != -1) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4482] == 0) {
                  {
                  fprintf(_coverage_fout, "4482\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4482] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___3 = ptr;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4483] == 0) {
                  {
                  fprintf(_coverage_fout, "4483\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4483] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                ptr ++;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4484] == 0) {
                  {
                  fprintf(_coverage_fout, "4484\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4484] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp___3 == 46) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4480] == 0) {
                    {
                    fprintf(_coverage_fout, "4480\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4480] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  dp_or_e = 1;
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[4481] == 0) {
                    {
                    fprintf(_coverage_fout, "4481\n");
                    fflush(_coverage_fout);
                    ___coverage_array[4481] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  dp_or_e = 2;
                }
                goto check_digits;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4485] == 0) {
                  {
                  fprintf(_coverage_fout, "4485\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4485] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4487] == 0) {
                {
                fprintf(_coverage_fout, "4487\n");
                fflush(_coverage_fout);
                ___coverage_array[4487] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4491] == 0) {
            {
            fprintf(_coverage_fout, "4491\n");
            fflush(_coverage_fout);
            ___coverage_array[4491] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((unsigned char)0);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4493] == 0) {
          {
          fprintf(_coverage_fout, "4493\n");
          fflush(_coverage_fout);
          ___coverage_array[4493] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((unsigned char)0);
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4495] == 0) {
        {
        fprintf(_coverage_fout, "4495\n");
        fflush(_coverage_fout);
        ___coverage_array[4495] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((unsigned char)0);
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4551] == 0) {
    {
    fprintf(_coverage_fout, "4551\n");
    fflush(_coverage_fout);
    ___coverage_array[4551] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )ptr != (unsigned int )(str + length)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4501] == 0) {
      {
      fprintf(_coverage_fout, "4501\n");
      fflush(_coverage_fout);
      ___coverage_array[4501] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! allow_errors) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4497] == 0) {
        {
        fprintf(_coverage_fout, "4497\n");
        fflush(_coverage_fout);
        ___coverage_array[4497] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((unsigned char)0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4498] == 0) {
        {
        fprintf(_coverage_fout, "4498\n");
        fflush(_coverage_fout);
        ___coverage_array[4498] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4502] == 0) {
      {
      fprintf(_coverage_fout, "4502\n");
      fflush(_coverage_fout);
      ___coverage_array[4502] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (allow_errors == -1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4499] == 0) {
        {
        fprintf(_coverage_fout, "4499\n");
        fflush(_coverage_fout);
        ___coverage_array[4499] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_error(1 << 3L, "A non well formed numeric value encountered");
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4500] == 0) {
        {
        fprintf(_coverage_fout, "4500\n");
        fflush(_coverage_fout);
        ___coverage_array[4500] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4503] == 0) {
      {
      fprintf(_coverage_fout, "4503\n");
      fflush(_coverage_fout);
      ___coverage_array[4503] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4552] == 0) {
    {
    fprintf(_coverage_fout, "4552\n");
    fflush(_coverage_fout);
    ___coverage_array[4552] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )type == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4536] == 0) {
      {
      fprintf(_coverage_fout, "4536\n");
      fflush(_coverage_fout);
      ___coverage_array[4536] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (digits == 10) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4530] == 0) {
        {
        fprintf(_coverage_fout, "4530\n");
        fflush(_coverage_fout);
        ___coverage_array[4530] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4515] == 0) {
          {
          fprintf(_coverage_fout, "4515\n");
          fflush(_coverage_fout);
          ___coverage_array[4515] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __s1_len = strlen(ptr + - digits);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4516] == 0) {
          {
          fprintf(_coverage_fout, "4516\n");
          fflush(_coverage_fout);
          ___coverage_array[4516] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __s2_len = strlen(long_min_digits);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4517] == 0) {
          {
          fprintf(_coverage_fout, "4517\n");
          fflush(_coverage_fout);
          ___coverage_array[4517] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! ((unsigned int )((void const   *)((ptr + - digits) + 1)) - (unsigned int )((void const   *)(ptr + - digits)) == 1U)) {
          goto _L___7;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4510] == 0) {
            {
            fprintf(_coverage_fout, "4510\n");
            fflush(_coverage_fout);
            ___coverage_array[4510] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (__s1_len >= 4U) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4508] == 0) {
              {
              fprintf(_coverage_fout, "4508\n");
              fflush(_coverage_fout);
              ___coverage_array[4508] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _L___7: /* CIL Label */ 
            if (! ((unsigned int )((void const   *)(long_min_digits + 1)) - (unsigned int )((void const   *)(long_min_digits)) == 1U)) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4504] == 0) {
                {
                fprintf(_coverage_fout, "4504\n");
                fflush(_coverage_fout);
                ___coverage_array[4504] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___10 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4507] == 0) {
                {
                fprintf(_coverage_fout, "4507\n");
                fflush(_coverage_fout);
                ___coverage_array[4507] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (__s2_len >= 4U) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4505] == 0) {
                  {
                  fprintf(_coverage_fout, "4505\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4505] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___10 = 1;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4506] == 0) {
                  {
                  fprintf(_coverage_fout, "4506\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4506] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___10 = 0;
              }
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4509] == 0) {
              {
              fprintf(_coverage_fout, "4509\n");
              fflush(_coverage_fout);
              ___coverage_array[4509] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___10 = 0;
          }
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4518] == 0) {
          {
          fprintf(_coverage_fout, "4518\n");
          fflush(_coverage_fout);
          ___coverage_array[4518] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___10) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4511] == 0) {
            {
            fprintf(_coverage_fout, "4511\n");
            fflush(_coverage_fout);
            ___coverage_array[4511] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___5 = __builtin_strcmp(ptr + - digits, long_min_digits);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4512] == 0) {
            {
            fprintf(_coverage_fout, "4512\n");
            fflush(_coverage_fout);
            ___coverage_array[4512] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = tmp___5;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4513] == 0) {
            {
            fprintf(_coverage_fout, "4513\n");
            fflush(_coverage_fout);
            ___coverage_array[4513] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = __builtin_strcmp(ptr + - digits, long_min_digits);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4514] == 0) {
            {
            fprintf(_coverage_fout, "4514\n");
            fflush(_coverage_fout);
            ___coverage_array[4514] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = tmp___8;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4519] == 0) {
          {
          fprintf(_coverage_fout, "4519\n");
          fflush(_coverage_fout);
          ___coverage_array[4519] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = __builtin_strcmp(ptr + - digits, long_min_digits);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4520] == 0) {
          {
          fprintf(_coverage_fout, "4520\n");
          fflush(_coverage_fout);
          ___coverage_array[4520] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___9 = tmp___8;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4531] == 0) {
        {
        fprintf(_coverage_fout, "4531\n");
        fflush(_coverage_fout);
        ___coverage_array[4531] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      cmp = tmp___9;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4532] == 0) {
        {
        fprintf(_coverage_fout, "4532\n");
        fflush(_coverage_fout);
        ___coverage_array[4532] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (cmp < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4521] == 0) {
          {
          fprintf(_coverage_fout, "4521\n");
          fflush(_coverage_fout);
          ___coverage_array[4521] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4529] == 0) {
          {
          fprintf(_coverage_fout, "4529\n");
          fflush(_coverage_fout);
          ___coverage_array[4529] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (cmp == 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4523] == 0) {
            {
            fprintf(_coverage_fout, "4523\n");
            fflush(_coverage_fout);
            ___coverage_array[4523] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*str == 45) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4522] == 0) {
              {
              fprintf(_coverage_fout, "4522\n");
              fflush(_coverage_fout);
              ___coverage_array[4522] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            goto _L___8;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4527] == 0) {
            {
            fprintf(_coverage_fout, "4527\n");
            fflush(_coverage_fout);
            ___coverage_array[4527] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___8: /* CIL Label */ 
          if (dval) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4524] == 0) {
              {
              fprintf(_coverage_fout, "4524\n");
              fflush(_coverage_fout);
              ___coverage_array[4524] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___11 = zend_strtod(str, (char const   **)((void *)0));
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4525] == 0) {
              {
              fprintf(_coverage_fout, "4525\n");
              fflush(_coverage_fout);
              ___coverage_array[4525] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *dval = (double )tmp___11;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4526] == 0) {
              {
              fprintf(_coverage_fout, "4526\n");
              fflush(_coverage_fout);
              ___coverage_array[4526] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4528] == 0) {
            {
            fprintf(_coverage_fout, "4528\n");
            fflush(_coverage_fout);
            ___coverage_array[4528] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((unsigned char)2);
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4533] == 0) {
        {
        fprintf(_coverage_fout, "4533\n");
        fflush(_coverage_fout);
        ___coverage_array[4533] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4537] == 0) {
      {
      fprintf(_coverage_fout, "4537\n");
      fflush(_coverage_fout);
      ___coverage_array[4537] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (lval) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4534] == 0) {
        {
        fprintf(_coverage_fout, "4534\n");
        fflush(_coverage_fout);
        ___coverage_array[4534] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *lval = strtol((char const   */* __restrict  */)str,
                     (char **/* __restrict  */)((void *)0), base);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4535] == 0) {
        {
        fprintf(_coverage_fout, "4535\n");
        fflush(_coverage_fout);
        ___coverage_array[4535] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4538] == 0) {
      {
      fprintf(_coverage_fout, "4538\n");
      fflush(_coverage_fout);
      ___coverage_array[4538] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((unsigned char)1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4541] == 0) {
      {
      fprintf(_coverage_fout, "4541\n");
      fflush(_coverage_fout);
      ___coverage_array[4541] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (dval) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4539] == 0) {
        {
        fprintf(_coverage_fout, "4539\n");
        fflush(_coverage_fout);
        ___coverage_array[4539] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *dval = local_dval;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4540] == 0) {
        {
        fprintf(_coverage_fout, "4540\n");
        fflush(_coverage_fout);
        ___coverage_array[4540] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4542] == 0) {
      {
      fprintf(_coverage_fout, "4542\n");
      fflush(_coverage_fout);
      ___coverage_array[4542] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((unsigned char)2);
  }
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4574] == 0) {
    {
    fprintf(_coverage_fout, "4574\n");
    fflush(_coverage_fout);
    ___coverage_array[4574] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = haystack;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4575] == 0) {
    {
    fprintf(_coverage_fout, "4575\n");
    fflush(_coverage_fout);
    ___coverage_array[4575] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ne = *(needle + (needle_len - 1));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4576] == 0) {
    {
    fprintf(_coverage_fout, "4576\n");
    fflush(_coverage_fout);
    ___coverage_array[4576] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (needle_len == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4553] == 0) {
      {
      fprintf(_coverage_fout, "4553\n");
      fflush(_coverage_fout);
      ___coverage_array[4553] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = memchr((void const   *)p, (int )*needle, (unsigned int )(end - p));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4554] == 0) {
      {
      fprintf(_coverage_fout, "4554\n");
      fflush(_coverage_fout);
      ___coverage_array[4554] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4555] == 0) {
      {
      fprintf(_coverage_fout, "4555\n");
      fflush(_coverage_fout);
      ___coverage_array[4555] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4577] == 0) {
    {
    fprintf(_coverage_fout, "4577\n");
    fflush(_coverage_fout);
    ___coverage_array[4577] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (needle_len > end - haystack) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4556] == 0) {
      {
      fprintf(_coverage_fout, "4556\n");
      fflush(_coverage_fout);
      ___coverage_array[4556] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4557] == 0) {
      {
      fprintf(_coverage_fout, "4557\n");
      fflush(_coverage_fout);
      ___coverage_array[4557] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4578] == 0) {
    {
    fprintf(_coverage_fout, "4578\n");
    fflush(_coverage_fout);
    ___coverage_array[4578] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  end -= needle_len;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4579] == 0) {
    {
    fprintf(_coverage_fout, "4579\n");
    fflush(_coverage_fout);
    ___coverage_array[4579] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4568] == 0) {
      {
      fprintf(_coverage_fout, "4568\n");
      fflush(_coverage_fout);
      ___coverage_array[4568] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )p <= (unsigned int )end) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4558] == 0) {
        {
        fprintf(_coverage_fout, "4558\n");
        fflush(_coverage_fout);
        ___coverage_array[4558] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4569] == 0) {
      {
      fprintf(_coverage_fout, "4569\n");
      fflush(_coverage_fout);
      ___coverage_array[4569] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = memchr((void const   *)p, (int )*needle,
                     (unsigned int )((end - p) + 1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4570] == 0) {
      {
      fprintf(_coverage_fout, "4570\n");
      fflush(_coverage_fout);
      ___coverage_array[4570] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = (char *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4571] == 0) {
      {
      fprintf(_coverage_fout, "4571\n");
      fflush(_coverage_fout);
      ___coverage_array[4571] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (p) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4564] == 0) {
        {
        fprintf(_coverage_fout, "4564\n");
        fflush(_coverage_fout);
        ___coverage_array[4564] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )ne == (int )*(p + (needle_len - 1))) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4561] == 0) {
          {
          fprintf(_coverage_fout, "4561\n");
          fflush(_coverage_fout);
          ___coverage_array[4561] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = memcmp((void const   *)needle, (void const   *)p,
                         (unsigned int )(needle_len - 1));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4562] == 0) {
          {
          fprintf(_coverage_fout, "4562\n");
          fflush(_coverage_fout);
          ___coverage_array[4562] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4559] == 0) {
            {
            fprintf(_coverage_fout, "4559\n");
            fflush(_coverage_fout);
            ___coverage_array[4559] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4560] == 0) {
            {
            fprintf(_coverage_fout, "4560\n");
            fflush(_coverage_fout);
            ___coverage_array[4560] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (p);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4563] == 0) {
          {
          fprintf(_coverage_fout, "4563\n");
          fflush(_coverage_fout);
          ___coverage_array[4563] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4565] == 0) {
        {
        fprintf(_coverage_fout, "4565\n");
        fflush(_coverage_fout);
        ___coverage_array[4565] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4572] == 0) {
      {
      fprintf(_coverage_fout, "4572\n");
      fflush(_coverage_fout);
      ___coverage_array[4572] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )p == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4566] == 0) {
        {
        fprintf(_coverage_fout, "4566\n");
        fflush(_coverage_fout);
        ___coverage_array[4566] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((char *)((void *)0));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4567] == 0) {
        {
        fprintf(_coverage_fout, "4567\n");
        fflush(_coverage_fout);
        ___coverage_array[4567] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4573] == 0) {
      {
      fprintf(_coverage_fout, "4573\n");
      fflush(_coverage_fout);
      ___coverage_array[4573] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4580] == 0) {
    {
    fprintf(_coverage_fout, "4580\n");
    fflush(_coverage_fout);
    ___coverage_array[4580] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((char *)((void *)0));
}
}
__inline static void const   *zend_memrchr(void const   *s , int c , size_t n ) 
{ register unsigned char const   *e ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4589] == 0) {
    {
    fprintf(_coverage_fout, "4589\n");
    fflush(_coverage_fout);
    ___coverage_array[4589] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (n <= 0U) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4581] == 0) {
      {
      fprintf(_coverage_fout, "4581\n");
      fflush(_coverage_fout);
      ___coverage_array[4581] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((void const   *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4582] == 0) {
      {
      fprintf(_coverage_fout, "4582\n");
      fflush(_coverage_fout);
      ___coverage_array[4582] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4590] == 0) {
    {
    fprintf(_coverage_fout, "4590\n");
    fflush(_coverage_fout);
    ___coverage_array[4590] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  e = ((unsigned char const   *)s + n) - 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4591] == 0) {
    {
    fprintf(_coverage_fout, "4591\n");
    fflush(_coverage_fout);
    ___coverage_array[4591] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4586] == 0) {
      {
      fprintf(_coverage_fout, "4586\n");
      fflush(_coverage_fout);
      ___coverage_array[4586] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )e >= (unsigned int )((unsigned char const   *)s)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4583] == 0) {
        {
        fprintf(_coverage_fout, "4583\n");
        fflush(_coverage_fout);
        ___coverage_array[4583] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4587] == 0) {
      {
      fprintf(_coverage_fout, "4587\n");
      fflush(_coverage_fout);
      ___coverage_array[4587] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*e == (int const   )((unsigned char const   )c)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4584] == 0) {
        {
        fprintf(_coverage_fout, "4584\n");
        fflush(_coverage_fout);
        ___coverage_array[4584] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((void const   *)e);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4585] == 0) {
        {
        fprintf(_coverage_fout, "4585\n");
        fflush(_coverage_fout);
        ___coverage_array[4585] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4588] == 0) {
      {
      fprintf(_coverage_fout, "4588\n");
      fflush(_coverage_fout);
      ___coverage_array[4588] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    e --;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4592] == 0) {
    {
    fprintf(_coverage_fout, "4592\n");
    fflush(_coverage_fout);
    ___coverage_array[4592] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((void const   *)((void *)0));
}
}
extern int __attribute__((__visibility__("default")))  increment_function(zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  decrement_function(zval *op2 ) ;
extern void __attribute__((__visibility__("default")))  convert_scalar_to_number(zval *op ) ;
extern void __attribute__((__visibility__("default")))  _convert_to_string(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_long(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_double(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_long_base(zval *op ,
                                                                             int base ) ;
extern void __attribute__((__visibility__("default")))  convert_to_null(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_boolean(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_array(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_object(zval *op ) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_long_ex(int argc 
                                                                                 , ...) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_double_ex(int argc 
                                                                                   , ...) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_string_ex(int argc 
                                                                                   , ...) ;
extern int __attribute__((__visibility__("default")))  add_char_to_string(zval *result ,
                                                                          zval const   *op1 ,
                                                                          zval const   *op2 ) ;
extern int __attribute__((__visibility__("default")))  add_string_to_string(zval *result ,
                                                                            zval const   *op1 ,
                                                                            zval const   *op2 ) ;
extern double __attribute__((__visibility__("default")))  zend_string_to_double(char const   *number ,
                                                                                zend_uint length ) ;
extern int __attribute__((__visibility__("default")))  zval_is_true(zval *op ) ;
extern int __attribute__((__visibility__("default")))  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")))  string_compare_function_ex(zval *result ,
                                                                                  zval *op1 ,
                                                                                  zval *op2 ,
                                                                                  zend_bool case_insensitive ) ;
extern int __attribute__((__visibility__("default")))  string_compare_function(zval *result ,
                                                                               zval *op1 ,
                                                                               zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_case_compare_function(zval *result ,
                                                                                    zval *op1 ,
                                                                                    zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_locale_compare_function(zval *result ,
                                                                                      zval *op1 ,
                                                                                      zval *op2 ) ;
extern void __attribute__((__visibility__("default")))  zend_str_tolower(char *str ,
                                                                         unsigned int length ) ;
extern char __attribute__((__visibility__("default")))  *zend_str_tolower_copy(char *dest ,
                                                                               char const   *source ,
                                                                               unsigned int length ) ;
extern char __attribute__((__visibility__("default")))  *zend_str_tolower_dup(char const   *source ,
                                                                              unsigned int length ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strcmp(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_strcasecmp(zval *s1 ,
                                                                                   zval *s2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strncasecmp(zval *s1 ,
                                                                                    zval *s2 ,
                                                                                    zval *s3 ) ;
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_strncmp(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_strncasecmp(char const   *s1 ,
                                                                               uint len1 ,
                                                                               char const   *s2 ,
                                                                               uint len2 ,
                                                                               uint length ) ;
extern void __attribute__((__visibility__("default")))  zendi_smart_strcmp(zval *result ,
                                                                           zval *s1 ,
                                                                           zval *s2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_symbol_tables(zval *result ,
                                                                                   HashTable *ht1 ,
                                                                                   HashTable *ht2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_arrays(zval *result ,
                                                                            zval *a1 ,
                                                                            zval *a2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_objects(zval *result ,
                                                                             zval *o1 ,
                                                                             zval *o2 ) ;
extern int __attribute__((__visibility__("default")))  zend_atoi(char const   *str ,
                                                                 int str_len ) ;
extern long __attribute__((__visibility__("default")))  zend_atol(char const   *str ,
                                                                  int str_len ) ;
extern void __attribute__((__visibility__("default")))  zend_locale_sprintf_double(zval *op ) ;
__inline static int ( __attribute__((__always_inline__)) fast_increment_function)(zval *op1 ) 
{ long tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4596] == 0) {
    {
    fprintf(_coverage_fout, "4596\n");
    fflush(_coverage_fout);
    ___coverage_array[4596] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4597] == 0) {
    {
    fprintf(_coverage_fout, "4597\n");
    fflush(_coverage_fout);
    ___coverage_array[4597] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4593] == 0) {
      {
      fprintf(_coverage_fout, "4593\n");
      fflush(_coverage_fout);
      ___coverage_array[4593] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __asm__  ("incl (%0)\n\t"
              "jno  0f\n\t"
              "movl $0x0, (%0)\n\t"
              "movl $0x41e00000, 0x4(%0)\n\t"
              "movb $0x2,0xc(%0)\n"
              "0:": : "r" (op1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4594] == 0) {
      {
      fprintf(_coverage_fout, "4594\n");
      fflush(_coverage_fout);
      ___coverage_array[4594] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4595] == 0) {
      {
      fprintf(_coverage_fout, "4595\n");
      fflush(_coverage_fout);
      ___coverage_array[4595] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4598] == 0) {
    {
    fprintf(_coverage_fout, "4598\n");
    fflush(_coverage_fout);
    ___coverage_array[4598] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = increment_function(op1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4599] == 0) {
    {
    fprintf(_coverage_fout, "4599\n");
    fflush(_coverage_fout);
    ___coverage_array[4599] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___0);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_decrement_function)(zval *op1 ) 
{ long tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4603] == 0) {
    {
    fprintf(_coverage_fout, "4603\n");
    fflush(_coverage_fout);
    ___coverage_array[4603] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4604] == 0) {
    {
    fprintf(_coverage_fout, "4604\n");
    fflush(_coverage_fout);
    ___coverage_array[4604] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4600] == 0) {
      {
      fprintf(_coverage_fout, "4600\n");
      fflush(_coverage_fout);
      ___coverage_array[4600] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __asm__  ("decl (%0)\n\t"
              "jno  0f\n\t"
              "movl $0x00200000, (%0)\n\t"
              "movl $0xc1e00000, 0x4(%0)\n\t"
              "movb $0x2,0xc(%0)\n"
              "0:": : "r" (op1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4601] == 0) {
      {
      fprintf(_coverage_fout, "4601\n");
      fflush(_coverage_fout);
      ___coverage_array[4601] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4602] == 0) {
      {
      fprintf(_coverage_fout, "4602\n");
      fflush(_coverage_fout);
      ___coverage_array[4602] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4605] == 0) {
    {
    fprintf(_coverage_fout, "4605\n");
    fflush(_coverage_fout);
    ___coverage_array[4605] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = decrement_function(op1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4606] == 0) {
    {
    fprintf(_coverage_fout, "4606\n");
    fflush(_coverage_fout);
    ___coverage_array[4606] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___0);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_add_function)(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4631] == 0) {
    {
    fprintf(_coverage_fout, "4631\n");
    fflush(_coverage_fout);
    ___coverage_array[4631] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4632] == 0) {
    {
    fprintf(_coverage_fout, "4632\n");
    fflush(_coverage_fout);
    ___coverage_array[4632] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4615] == 0) {
      {
      fprintf(_coverage_fout, "4615\n");
      fflush(_coverage_fout);
      ___coverage_array[4615] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4616] == 0) {
      {
      fprintf(_coverage_fout, "4616\n");
      fflush(_coverage_fout);
      ___coverage_array[4616] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4607] == 0) {
        {
        fprintf(_coverage_fout, "4607\n");
        fflush(_coverage_fout);
        ___coverage_array[4607] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __asm__  ("movl\t(%1), %%eax\n\t"
                "addl   (%2), %%eax\n\t"
                "jo     0f\n\t"
                "movl   %%eax, (%0)\n\t"
                "movb   $0x1,0xc(%0)\n\t"
                "jmp    1f\n"
                "0:\n\t"
                "fildl\t(%1)\n\t"
                "fildl\t(%2)\n\t"
                "faddp\t%%st, %%st(1)\n\t"
                "movb   $0x2,0xc(%0)\n\t"
                "fstpl\t(%0)\n"
                "1:": : "r" (result), "r" (op1), "r" (op2): "eax");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4608] == 0) {
        {
        fprintf(_coverage_fout, "4608\n");
        fflush(_coverage_fout);
        ___coverage_array[4608] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4613] == 0) {
        {
        fprintf(_coverage_fout, "4613\n");
        fflush(_coverage_fout);
        ___coverage_array[4613] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4614] == 0) {
        {
        fprintf(_coverage_fout, "4614\n");
        fflush(_coverage_fout);
        ___coverage_array[4614] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4609] == 0) {
          {
          fprintf(_coverage_fout, "4609\n");
          fflush(_coverage_fout);
          ___coverage_array[4609] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.dval = (double )op1->value.lval + op2->value.dval;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4610] == 0) {
          {
          fprintf(_coverage_fout, "4610\n");
          fflush(_coverage_fout);
          ___coverage_array[4610] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4611] == 0) {
          {
          fprintf(_coverage_fout, "4611\n");
          fflush(_coverage_fout);
          ___coverage_array[4611] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4612] == 0) {
          {
          fprintf(_coverage_fout, "4612\n");
          fflush(_coverage_fout);
          ___coverage_array[4612] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4629] == 0) {
      {
      fprintf(_coverage_fout, "4629\n");
      fflush(_coverage_fout);
      ___coverage_array[4629] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4630] == 0) {
      {
      fprintf(_coverage_fout, "4630\n");
      fflush(_coverage_fout);
      ___coverage_array[4630] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4626] == 0) {
        {
        fprintf(_coverage_fout, "4626\n");
        fflush(_coverage_fout);
        ___coverage_array[4626] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4627] == 0) {
        {
        fprintf(_coverage_fout, "4627\n");
        fflush(_coverage_fout);
        ___coverage_array[4627] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4617] == 0) {
          {
          fprintf(_coverage_fout, "4617\n");
          fflush(_coverage_fout);
          ___coverage_array[4617] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.dval = op1->value.dval + op2->value.dval;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4618] == 0) {
          {
          fprintf(_coverage_fout, "4618\n");
          fflush(_coverage_fout);
          ___coverage_array[4618] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4619] == 0) {
          {
          fprintf(_coverage_fout, "4619\n");
          fflush(_coverage_fout);
          ___coverage_array[4619] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4624] == 0) {
          {
          fprintf(_coverage_fout, "4624\n");
          fflush(_coverage_fout);
          ___coverage_array[4624] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4625] == 0) {
          {
          fprintf(_coverage_fout, "4625\n");
          fflush(_coverage_fout);
          ___coverage_array[4625] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4620] == 0) {
            {
            fprintf(_coverage_fout, "4620\n");
            fflush(_coverage_fout);
            ___coverage_array[4620] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->value.dval = op1->value.dval + (double )op2->value.lval;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4621] == 0) {
            {
            fprintf(_coverage_fout, "4621\n");
            fflush(_coverage_fout);
            ___coverage_array[4621] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->type = (unsigned char)2;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4622] == 0) {
            {
            fprintf(_coverage_fout, "4622\n");
            fflush(_coverage_fout);
            ___coverage_array[4622] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4623] == 0) {
            {
            fprintf(_coverage_fout, "4623\n");
            fflush(_coverage_fout);
            ___coverage_array[4623] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4628] == 0) {
        {
        fprintf(_coverage_fout, "4628\n");
        fflush(_coverage_fout);
        ___coverage_array[4628] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4633] == 0) {
    {
    fprintf(_coverage_fout, "4633\n");
    fflush(_coverage_fout);
    ___coverage_array[4633] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = add_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4634] == 0) {
    {
    fprintf(_coverage_fout, "4634\n");
    fflush(_coverage_fout);
    ___coverage_array[4634] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___5);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_sub_function)(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4659] == 0) {
    {
    fprintf(_coverage_fout, "4659\n");
    fflush(_coverage_fout);
    ___coverage_array[4659] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4660] == 0) {
    {
    fprintf(_coverage_fout, "4660\n");
    fflush(_coverage_fout);
    ___coverage_array[4660] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4643] == 0) {
      {
      fprintf(_coverage_fout, "4643\n");
      fflush(_coverage_fout);
      ___coverage_array[4643] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4644] == 0) {
      {
      fprintf(_coverage_fout, "4644\n");
      fflush(_coverage_fout);
      ___coverage_array[4644] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4635] == 0) {
        {
        fprintf(_coverage_fout, "4635\n");
        fflush(_coverage_fout);
        ___coverage_array[4635] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __asm__  ("movl\t(%1), %%eax\n\t"
                "subl   (%2), %%eax\n\t"
                "jo     0f\n\t"
                "movl   %%eax, (%0)\n\t"
                "movb   $0x1,0xc(%0)\n\t"
                "jmp    1f\n"
                "0:\n\t"
                "fildl\t(%2)\n\t"
                "fildl\t(%1)\n\t"
                "fsubp\t%%st, %%st(1)\n\t"
                "movb   $0x2,0xc(%0)\n\t"
                "fstpl\t(%0)\n"
                "1:": : "r" (result), "r" (op1), "r" (op2): "eax");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4636] == 0) {
        {
        fprintf(_coverage_fout, "4636\n");
        fflush(_coverage_fout);
        ___coverage_array[4636] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4641] == 0) {
        {
        fprintf(_coverage_fout, "4641\n");
        fflush(_coverage_fout);
        ___coverage_array[4641] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4642] == 0) {
        {
        fprintf(_coverage_fout, "4642\n");
        fflush(_coverage_fout);
        ___coverage_array[4642] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4637] == 0) {
          {
          fprintf(_coverage_fout, "4637\n");
          fflush(_coverage_fout);
          ___coverage_array[4637] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.dval = (double )op1->value.lval - op2->value.dval;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4638] == 0) {
          {
          fprintf(_coverage_fout, "4638\n");
          fflush(_coverage_fout);
          ___coverage_array[4638] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4639] == 0) {
          {
          fprintf(_coverage_fout, "4639\n");
          fflush(_coverage_fout);
          ___coverage_array[4639] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4640] == 0) {
          {
          fprintf(_coverage_fout, "4640\n");
          fflush(_coverage_fout);
          ___coverage_array[4640] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4657] == 0) {
      {
      fprintf(_coverage_fout, "4657\n");
      fflush(_coverage_fout);
      ___coverage_array[4657] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4658] == 0) {
      {
      fprintf(_coverage_fout, "4658\n");
      fflush(_coverage_fout);
      ___coverage_array[4658] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4654] == 0) {
        {
        fprintf(_coverage_fout, "4654\n");
        fflush(_coverage_fout);
        ___coverage_array[4654] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4655] == 0) {
        {
        fprintf(_coverage_fout, "4655\n");
        fflush(_coverage_fout);
        ___coverage_array[4655] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4645] == 0) {
          {
          fprintf(_coverage_fout, "4645\n");
          fflush(_coverage_fout);
          ___coverage_array[4645] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.dval = op1->value.dval - op2->value.dval;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4646] == 0) {
          {
          fprintf(_coverage_fout, "4646\n");
          fflush(_coverage_fout);
          ___coverage_array[4646] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4647] == 0) {
          {
          fprintf(_coverage_fout, "4647\n");
          fflush(_coverage_fout);
          ___coverage_array[4647] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4652] == 0) {
          {
          fprintf(_coverage_fout, "4652\n");
          fflush(_coverage_fout);
          ___coverage_array[4652] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4653] == 0) {
          {
          fprintf(_coverage_fout, "4653\n");
          fflush(_coverage_fout);
          ___coverage_array[4653] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4648] == 0) {
            {
            fprintf(_coverage_fout, "4648\n");
            fflush(_coverage_fout);
            ___coverage_array[4648] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->value.dval = op1->value.dval - (double )op2->value.lval;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4649] == 0) {
            {
            fprintf(_coverage_fout, "4649\n");
            fflush(_coverage_fout);
            ___coverage_array[4649] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->type = (unsigned char)2;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4650] == 0) {
            {
            fprintf(_coverage_fout, "4650\n");
            fflush(_coverage_fout);
            ___coverage_array[4650] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4651] == 0) {
            {
            fprintf(_coverage_fout, "4651\n");
            fflush(_coverage_fout);
            ___coverage_array[4651] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4656] == 0) {
        {
        fprintf(_coverage_fout, "4656\n");
        fflush(_coverage_fout);
        ___coverage_array[4656] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4661] == 0) {
    {
    fprintf(_coverage_fout, "4661\n");
    fflush(_coverage_fout);
    ___coverage_array[4661] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = sub_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4662] == 0) {
    {
    fprintf(_coverage_fout, "4662\n");
    fflush(_coverage_fout);
    ___coverage_array[4662] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___5);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_mul_function)(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) 
{ long overflow ;
  long __tmpvar ;
  long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4694] == 0) {
    {
    fprintf(_coverage_fout, "4694\n");
    fflush(_coverage_fout);
    ___coverage_array[4694] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4695] == 0) {
    {
    fprintf(_coverage_fout, "4695\n");
    fflush(_coverage_fout);
    ___coverage_array[4695] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4678] == 0) {
      {
      fprintf(_coverage_fout, "4678\n");
      fflush(_coverage_fout);
      ___coverage_array[4678] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4679] == 0) {
      {
      fprintf(_coverage_fout, "4679\n");
      fflush(_coverage_fout);
      ___coverage_array[4679] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4669] == 0) {
        {
        fprintf(_coverage_fout, "4669\n");
        fflush(_coverage_fout);
        ___coverage_array[4669] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4665] == 0) {
          {
          fprintf(_coverage_fout, "4665\n");
          fflush(_coverage_fout);
          ___coverage_array[4665] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __asm__  ("imul %3,%0\n"
                  "adc $0,%1": "=r" (__tmpvar),
                  "=r" (overflow): "0" (op1->value.lval), "r" (op2->value.lval),
                  "1" (0));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4666] == 0) {
          {
          fprintf(_coverage_fout, "4666\n");
          fflush(_coverage_fout);
          ___coverage_array[4666] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (overflow) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4663] == 0) {
            {
            fprintf(_coverage_fout, "4663\n");
            fflush(_coverage_fout);
            ___coverage_array[4663] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->value.dval = (double )op1->value.lval * (double )op2->value.lval;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4664] == 0) {
            {
            fprintf(_coverage_fout, "4664\n");
            fflush(_coverage_fout);
            ___coverage_array[4664] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->value.lval = __tmpvar;
        }
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4670] == 0) {
        {
        fprintf(_coverage_fout, "4670\n");
        fflush(_coverage_fout);
        ___coverage_array[4670] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (overflow) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4667] == 0) {
          {
          fprintf(_coverage_fout, "4667\n");
          fflush(_coverage_fout);
          ___coverage_array[4667] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4668] == 0) {
          {
          fprintf(_coverage_fout, "4668\n");
          fflush(_coverage_fout);
          ___coverage_array[4668] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)1;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4671] == 0) {
        {
        fprintf(_coverage_fout, "4671\n");
        fflush(_coverage_fout);
        ___coverage_array[4671] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4676] == 0) {
        {
        fprintf(_coverage_fout, "4676\n");
        fflush(_coverage_fout);
        ___coverage_array[4676] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4677] == 0) {
        {
        fprintf(_coverage_fout, "4677\n");
        fflush(_coverage_fout);
        ___coverage_array[4677] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4672] == 0) {
          {
          fprintf(_coverage_fout, "4672\n");
          fflush(_coverage_fout);
          ___coverage_array[4672] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.dval = (double )op1->value.lval * op2->value.dval;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4673] == 0) {
          {
          fprintf(_coverage_fout, "4673\n");
          fflush(_coverage_fout);
          ___coverage_array[4673] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4674] == 0) {
          {
          fprintf(_coverage_fout, "4674\n");
          fflush(_coverage_fout);
          ___coverage_array[4674] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4675] == 0) {
          {
          fprintf(_coverage_fout, "4675\n");
          fflush(_coverage_fout);
          ___coverage_array[4675] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4692] == 0) {
      {
      fprintf(_coverage_fout, "4692\n");
      fflush(_coverage_fout);
      ___coverage_array[4692] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4693] == 0) {
      {
      fprintf(_coverage_fout, "4693\n");
      fflush(_coverage_fout);
      ___coverage_array[4693] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4689] == 0) {
        {
        fprintf(_coverage_fout, "4689\n");
        fflush(_coverage_fout);
        ___coverage_array[4689] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4690] == 0) {
        {
        fprintf(_coverage_fout, "4690\n");
        fflush(_coverage_fout);
        ___coverage_array[4690] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4680] == 0) {
          {
          fprintf(_coverage_fout, "4680\n");
          fflush(_coverage_fout);
          ___coverage_array[4680] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.dval = op1->value.dval * op2->value.dval;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4681] == 0) {
          {
          fprintf(_coverage_fout, "4681\n");
          fflush(_coverage_fout);
          ___coverage_array[4681] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)2;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4682] == 0) {
          {
          fprintf(_coverage_fout, "4682\n");
          fflush(_coverage_fout);
          ___coverage_array[4682] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4687] == 0) {
          {
          fprintf(_coverage_fout, "4687\n");
          fflush(_coverage_fout);
          ___coverage_array[4687] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4688] == 0) {
          {
          fprintf(_coverage_fout, "4688\n");
          fflush(_coverage_fout);
          ___coverage_array[4688] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4683] == 0) {
            {
            fprintf(_coverage_fout, "4683\n");
            fflush(_coverage_fout);
            ___coverage_array[4683] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->value.dval = op1->value.dval * (double )op2->value.lval;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4684] == 0) {
            {
            fprintf(_coverage_fout, "4684\n");
            fflush(_coverage_fout);
            ___coverage_array[4684] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->type = (unsigned char)2;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4685] == 0) {
            {
            fprintf(_coverage_fout, "4685\n");
            fflush(_coverage_fout);
            ___coverage_array[4685] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4686] == 0) {
            {
            fprintf(_coverage_fout, "4686\n");
            fflush(_coverage_fout);
            ___coverage_array[4686] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4691] == 0) {
        {
        fprintf(_coverage_fout, "4691\n");
        fflush(_coverage_fout);
        ___coverage_array[4691] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4696] == 0) {
    {
    fprintf(_coverage_fout, "4696\n");
    fflush(_coverage_fout);
    ___coverage_array[4696] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = mul_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4697] == 0) {
    {
    fprintf(_coverage_fout, "4697\n");
    fflush(_coverage_fout);
    ___coverage_array[4697] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___5);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_div_function)(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) 
{ long tmp ;
  int tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  long tmp___5 ;
  long tmp___6 ;
  long tmp___7 ;
  long tmp___8 ;
  long tmp___9 ;
  long tmp___10 ;
  long tmp___11 ;
  int __attribute__((__visibility__("default")))  tmp___12 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4702] == 0) {
    {
    fprintf(_coverage_fout, "4702\n");
    fflush(_coverage_fout);
    ___coverage_array[4702] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___11 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4703] == 0) {
    {
    fprintf(_coverage_fout, "4703\n");
    fflush(_coverage_fout);
    ___coverage_array[4703] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___11) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4700] == 0) {
      {
      fprintf(_coverage_fout, "4700\n");
      fflush(_coverage_fout);
      ___coverage_array[4700] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L: /* CIL Label */ 
    tmp___10 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4701] == 0) {
      {
      fprintf(_coverage_fout, "4701\n");
      fflush(_coverage_fout);
      ___coverage_array[4701] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___10) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4698] == 0) {
        {
        fprintf(_coverage_fout, "4698\n");
        fflush(_coverage_fout);
        ___coverage_array[4698] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4699] == 0) {
        {
        fprintf(_coverage_fout, "4699\n");
        fflush(_coverage_fout);
        ___coverage_array[4699] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4704] == 0) {
    {
    fprintf(_coverage_fout, "4704\n");
    fflush(_coverage_fout);
    ___coverage_array[4704] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___12 = div_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4705] == 0) {
    {
    fprintf(_coverage_fout, "4705\n");
    fflush(_coverage_fout);
    ___coverage_array[4705] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___12);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_mod_function)(zval *result ,
                                                                            zval *op1 ,
                                                                            zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4725] == 0) {
    {
    fprintf(_coverage_fout, "4725\n");
    fflush(_coverage_fout);
    ___coverage_array[4725] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4726] == 0) {
    {
    fprintf(_coverage_fout, "4726\n");
    fflush(_coverage_fout);
    ___coverage_array[4726] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4722] == 0) {
      {
      fprintf(_coverage_fout, "4722\n");
      fflush(_coverage_fout);
      ___coverage_array[4722] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4723] == 0) {
      {
      fprintf(_coverage_fout, "4723\n");
      fflush(_coverage_fout);
      ___coverage_array[4723] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4716] == 0) {
        {
        fprintf(_coverage_fout, "4716\n");
        fflush(_coverage_fout);
        ___coverage_array[4716] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = __builtin_expect((long )(op2->value.lval == 0L), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4717] == 0) {
        {
        fprintf(_coverage_fout, "4717\n");
        fflush(_coverage_fout);
        ___coverage_array[4717] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4706] == 0) {
          {
          fprintf(_coverage_fout, "4706\n");
          fflush(_coverage_fout);
          ___coverage_array[4706] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_error(1 << 1L, "Division by zero");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4707] == 0) {
          {
          fprintf(_coverage_fout, "4707\n");
          fflush(_coverage_fout);
          ___coverage_array[4707] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->value.lval = 0L;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4708] == 0) {
          {
          fprintf(_coverage_fout, "4708\n");
          fflush(_coverage_fout);
          ___coverage_array[4708] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result->type = (unsigned char)3;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4709] == 0) {
          {
          fprintf(_coverage_fout, "4709\n");
          fflush(_coverage_fout);
          ___coverage_array[4709] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (-1);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4714] == 0) {
          {
          fprintf(_coverage_fout, "4714\n");
          fflush(_coverage_fout);
          ___coverage_array[4714] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __builtin_expect((long )(op2->value.lval == -1L), 0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4715] == 0) {
          {
          fprintf(_coverage_fout, "4715\n");
          fflush(_coverage_fout);
          ___coverage_array[4715] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4710] == 0) {
            {
            fprintf(_coverage_fout, "4710\n");
            fflush(_coverage_fout);
            ___coverage_array[4710] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->value.lval = 0L;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4711] == 0) {
            {
            fprintf(_coverage_fout, "4711\n");
            fflush(_coverage_fout);
            ___coverage_array[4711] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result->type = (unsigned char)1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4712] == 0) {
            {
            fprintf(_coverage_fout, "4712\n");
            fflush(_coverage_fout);
            ___coverage_array[4712] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4713] == 0) {
            {
            fprintf(_coverage_fout, "4713\n");
            fflush(_coverage_fout);
            ___coverage_array[4713] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4718] == 0) {
        {
        fprintf(_coverage_fout, "4718\n");
        fflush(_coverage_fout);
        ___coverage_array[4718] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result->value.lval = op1->value.lval % op2->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4719] == 0) {
        {
        fprintf(_coverage_fout, "4719\n");
        fflush(_coverage_fout);
        ___coverage_array[4719] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result->type = (unsigned char)1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4720] == 0) {
        {
        fprintf(_coverage_fout, "4720\n");
        fflush(_coverage_fout);
        ___coverage_array[4720] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4721] == 0) {
        {
        fprintf(_coverage_fout, "4721\n");
        fflush(_coverage_fout);
        ___coverage_array[4721] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4724] == 0) {
      {
      fprintf(_coverage_fout, "4724\n");
      fflush(_coverage_fout);
      ___coverage_array[4724] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4727] == 0) {
    {
    fprintf(_coverage_fout, "4727\n");
    fflush(_coverage_fout);
    ___coverage_array[4727] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = mod_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4728] == 0) {
    {
    fprintf(_coverage_fout, "4728\n");
    fflush(_coverage_fout);
    ___coverage_array[4728] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___3);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_equal_function)(zval *result ,
                                                                              zval *op1 ,
                                                                              zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4746] == 0) {
    {
    fprintf(_coverage_fout, "4746\n");
    fflush(_coverage_fout);
    ___coverage_array[4746] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4747] == 0) {
    {
    fprintf(_coverage_fout, "4747\n");
    fflush(_coverage_fout);
    ___coverage_array[4747] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4734] == 0) {
      {
      fprintf(_coverage_fout, "4734\n");
      fflush(_coverage_fout);
      ___coverage_array[4734] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4735] == 0) {
      {
      fprintf(_coverage_fout, "4735\n");
      fflush(_coverage_fout);
      ___coverage_array[4735] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4729] == 0) {
        {
        fprintf(_coverage_fout, "4729\n");
        fflush(_coverage_fout);
        ___coverage_array[4729] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (op1->value.lval == op2->value.lval);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4732] == 0) {
        {
        fprintf(_coverage_fout, "4732\n");
        fflush(_coverage_fout);
        ___coverage_array[4732] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4733] == 0) {
        {
        fprintf(_coverage_fout, "4733\n");
        fflush(_coverage_fout);
        ___coverage_array[4733] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4730] == 0) {
          {
          fprintf(_coverage_fout, "4730\n");
          fflush(_coverage_fout);
          ___coverage_array[4730] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((double )op1->value.lval == op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4731] == 0) {
          {
          fprintf(_coverage_fout, "4731\n");
          fflush(_coverage_fout);
          ___coverage_array[4731] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4744] == 0) {
      {
      fprintf(_coverage_fout, "4744\n");
      fflush(_coverage_fout);
      ___coverage_array[4744] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4745] == 0) {
      {
      fprintf(_coverage_fout, "4745\n");
      fflush(_coverage_fout);
      ___coverage_array[4745] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4741] == 0) {
        {
        fprintf(_coverage_fout, "4741\n");
        fflush(_coverage_fout);
        ___coverage_array[4741] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4742] == 0) {
        {
        fprintf(_coverage_fout, "4742\n");
        fflush(_coverage_fout);
        ___coverage_array[4742] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4736] == 0) {
          {
          fprintf(_coverage_fout, "4736\n");
          fflush(_coverage_fout);
          ___coverage_array[4736] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (op1->value.dval == op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4739] == 0) {
          {
          fprintf(_coverage_fout, "4739\n");
          fflush(_coverage_fout);
          ___coverage_array[4739] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4740] == 0) {
          {
          fprintf(_coverage_fout, "4740\n");
          fflush(_coverage_fout);
          ___coverage_array[4740] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4737] == 0) {
            {
            fprintf(_coverage_fout, "4737\n");
            fflush(_coverage_fout);
            ___coverage_array[4737] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (op1->value.dval == (double )op2->value.lval);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4738] == 0) {
            {
            fprintf(_coverage_fout, "4738\n");
            fflush(_coverage_fout);
            ___coverage_array[4738] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4743] == 0) {
        {
        fprintf(_coverage_fout, "4743\n");
        fflush(_coverage_fout);
        ___coverage_array[4743] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4748] == 0) {
    {
    fprintf(_coverage_fout, "4748\n");
    fflush(_coverage_fout);
    ___coverage_array[4748] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  compare_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4749] == 0) {
    {
    fprintf(_coverage_fout, "4749\n");
    fflush(_coverage_fout);
    ___coverage_array[4749] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result->value.lval == 0L);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_not_equal_function)(zval *result ,
                                                                                  zval *op1 ,
                                                                                  zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4767] == 0) {
    {
    fprintf(_coverage_fout, "4767\n");
    fflush(_coverage_fout);
    ___coverage_array[4767] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4768] == 0) {
    {
    fprintf(_coverage_fout, "4768\n");
    fflush(_coverage_fout);
    ___coverage_array[4768] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4755] == 0) {
      {
      fprintf(_coverage_fout, "4755\n");
      fflush(_coverage_fout);
      ___coverage_array[4755] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4756] == 0) {
      {
      fprintf(_coverage_fout, "4756\n");
      fflush(_coverage_fout);
      ___coverage_array[4756] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4750] == 0) {
        {
        fprintf(_coverage_fout, "4750\n");
        fflush(_coverage_fout);
        ___coverage_array[4750] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (op1->value.lval != op2->value.lval);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4753] == 0) {
        {
        fprintf(_coverage_fout, "4753\n");
        fflush(_coverage_fout);
        ___coverage_array[4753] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4754] == 0) {
        {
        fprintf(_coverage_fout, "4754\n");
        fflush(_coverage_fout);
        ___coverage_array[4754] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4751] == 0) {
          {
          fprintf(_coverage_fout, "4751\n");
          fflush(_coverage_fout);
          ___coverage_array[4751] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((double )op1->value.lval != op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4752] == 0) {
          {
          fprintf(_coverage_fout, "4752\n");
          fflush(_coverage_fout);
          ___coverage_array[4752] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4765] == 0) {
      {
      fprintf(_coverage_fout, "4765\n");
      fflush(_coverage_fout);
      ___coverage_array[4765] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4766] == 0) {
      {
      fprintf(_coverage_fout, "4766\n");
      fflush(_coverage_fout);
      ___coverage_array[4766] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4762] == 0) {
        {
        fprintf(_coverage_fout, "4762\n");
        fflush(_coverage_fout);
        ___coverage_array[4762] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4763] == 0) {
        {
        fprintf(_coverage_fout, "4763\n");
        fflush(_coverage_fout);
        ___coverage_array[4763] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4757] == 0) {
          {
          fprintf(_coverage_fout, "4757\n");
          fflush(_coverage_fout);
          ___coverage_array[4757] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (op1->value.dval != op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4760] == 0) {
          {
          fprintf(_coverage_fout, "4760\n");
          fflush(_coverage_fout);
          ___coverage_array[4760] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4761] == 0) {
          {
          fprintf(_coverage_fout, "4761\n");
          fflush(_coverage_fout);
          ___coverage_array[4761] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4758] == 0) {
            {
            fprintf(_coverage_fout, "4758\n");
            fflush(_coverage_fout);
            ___coverage_array[4758] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (op1->value.dval != (double )op2->value.lval);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4759] == 0) {
            {
            fprintf(_coverage_fout, "4759\n");
            fflush(_coverage_fout);
            ___coverage_array[4759] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4764] == 0) {
        {
        fprintf(_coverage_fout, "4764\n");
        fflush(_coverage_fout);
        ___coverage_array[4764] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4769] == 0) {
    {
    fprintf(_coverage_fout, "4769\n");
    fflush(_coverage_fout);
    ___coverage_array[4769] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  compare_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4770] == 0) {
    {
    fprintf(_coverage_fout, "4770\n");
    fflush(_coverage_fout);
    ___coverage_array[4770] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result->value.lval != 0L);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_is_smaller_function)(zval *result ,
                                                                                   zval *op1 ,
                                                                                   zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4788] == 0) {
    {
    fprintf(_coverage_fout, "4788\n");
    fflush(_coverage_fout);
    ___coverage_array[4788] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4789] == 0) {
    {
    fprintf(_coverage_fout, "4789\n");
    fflush(_coverage_fout);
    ___coverage_array[4789] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4776] == 0) {
      {
      fprintf(_coverage_fout, "4776\n");
      fflush(_coverage_fout);
      ___coverage_array[4776] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4777] == 0) {
      {
      fprintf(_coverage_fout, "4777\n");
      fflush(_coverage_fout);
      ___coverage_array[4777] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4771] == 0) {
        {
        fprintf(_coverage_fout, "4771\n");
        fflush(_coverage_fout);
        ___coverage_array[4771] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (op1->value.lval < op2->value.lval);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4774] == 0) {
        {
        fprintf(_coverage_fout, "4774\n");
        fflush(_coverage_fout);
        ___coverage_array[4774] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4775] == 0) {
        {
        fprintf(_coverage_fout, "4775\n");
        fflush(_coverage_fout);
        ___coverage_array[4775] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4772] == 0) {
          {
          fprintf(_coverage_fout, "4772\n");
          fflush(_coverage_fout);
          ___coverage_array[4772] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((double )op1->value.lval < op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4773] == 0) {
          {
          fprintf(_coverage_fout, "4773\n");
          fflush(_coverage_fout);
          ___coverage_array[4773] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4786] == 0) {
      {
      fprintf(_coverage_fout, "4786\n");
      fflush(_coverage_fout);
      ___coverage_array[4786] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4787] == 0) {
      {
      fprintf(_coverage_fout, "4787\n");
      fflush(_coverage_fout);
      ___coverage_array[4787] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4783] == 0) {
        {
        fprintf(_coverage_fout, "4783\n");
        fflush(_coverage_fout);
        ___coverage_array[4783] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4784] == 0) {
        {
        fprintf(_coverage_fout, "4784\n");
        fflush(_coverage_fout);
        ___coverage_array[4784] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4778] == 0) {
          {
          fprintf(_coverage_fout, "4778\n");
          fflush(_coverage_fout);
          ___coverage_array[4778] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (op1->value.dval < op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4781] == 0) {
          {
          fprintf(_coverage_fout, "4781\n");
          fflush(_coverage_fout);
          ___coverage_array[4781] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4782] == 0) {
          {
          fprintf(_coverage_fout, "4782\n");
          fflush(_coverage_fout);
          ___coverage_array[4782] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4779] == 0) {
            {
            fprintf(_coverage_fout, "4779\n");
            fflush(_coverage_fout);
            ___coverage_array[4779] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (op1->value.dval < (double )op2->value.lval);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4780] == 0) {
            {
            fprintf(_coverage_fout, "4780\n");
            fflush(_coverage_fout);
            ___coverage_array[4780] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4785] == 0) {
        {
        fprintf(_coverage_fout, "4785\n");
        fflush(_coverage_fout);
        ___coverage_array[4785] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4790] == 0) {
    {
    fprintf(_coverage_fout, "4790\n");
    fflush(_coverage_fout);
    ___coverage_array[4790] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  compare_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4791] == 0) {
    {
    fprintf(_coverage_fout, "4791\n");
    fflush(_coverage_fout);
    ___coverage_array[4791] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result->value.lval < 0L);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_is_smaller_or_equal_function)(zval *result ,
                                                                                            zval *op1 ,
                                                                                            zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4809] == 0) {
    {
    fprintf(_coverage_fout, "4809\n");
    fflush(_coverage_fout);
    ___coverage_array[4809] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4810] == 0) {
    {
    fprintf(_coverage_fout, "4810\n");
    fflush(_coverage_fout);
    ___coverage_array[4810] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4797] == 0) {
      {
      fprintf(_coverage_fout, "4797\n");
      fflush(_coverage_fout);
      ___coverage_array[4797] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4798] == 0) {
      {
      fprintf(_coverage_fout, "4798\n");
      fflush(_coverage_fout);
      ___coverage_array[4798] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4792] == 0) {
        {
        fprintf(_coverage_fout, "4792\n");
        fflush(_coverage_fout);
        ___coverage_array[4792] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (op1->value.lval <= op2->value.lval);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4795] == 0) {
        {
        fprintf(_coverage_fout, "4795\n");
        fflush(_coverage_fout);
        ___coverage_array[4795] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4796] == 0) {
        {
        fprintf(_coverage_fout, "4796\n");
        fflush(_coverage_fout);
        ___coverage_array[4796] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4793] == 0) {
          {
          fprintf(_coverage_fout, "4793\n");
          fflush(_coverage_fout);
          ___coverage_array[4793] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((double )op1->value.lval <= op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4794] == 0) {
          {
          fprintf(_coverage_fout, "4794\n");
          fflush(_coverage_fout);
          ___coverage_array[4794] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4807] == 0) {
      {
      fprintf(_coverage_fout, "4807\n");
      fflush(_coverage_fout);
      ___coverage_array[4807] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4808] == 0) {
      {
      fprintf(_coverage_fout, "4808\n");
      fflush(_coverage_fout);
      ___coverage_array[4808] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4804] == 0) {
        {
        fprintf(_coverage_fout, "4804\n");
        fflush(_coverage_fout);
        ___coverage_array[4804] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4805] == 0) {
        {
        fprintf(_coverage_fout, "4805\n");
        fflush(_coverage_fout);
        ___coverage_array[4805] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4799] == 0) {
          {
          fprintf(_coverage_fout, "4799\n");
          fflush(_coverage_fout);
          ___coverage_array[4799] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (op1->value.dval <= op2->value.dval);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4802] == 0) {
          {
          fprintf(_coverage_fout, "4802\n");
          fflush(_coverage_fout);
          ___coverage_array[4802] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4803] == 0) {
          {
          fprintf(_coverage_fout, "4803\n");
          fflush(_coverage_fout);
          ___coverage_array[4803] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4800] == 0) {
            {
            fprintf(_coverage_fout, "4800\n");
            fflush(_coverage_fout);
            ___coverage_array[4800] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (op1->value.dval <= (double )op2->value.lval);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4801] == 0) {
            {
            fprintf(_coverage_fout, "4801\n");
            fflush(_coverage_fout);
            ___coverage_array[4801] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4806] == 0) {
        {
        fprintf(_coverage_fout, "4806\n");
        fflush(_coverage_fout);
        ___coverage_array[4806] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4811] == 0) {
    {
    fprintf(_coverage_fout, "4811\n");
    fflush(_coverage_fout);
    ___coverage_array[4811] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  compare_function(result, op1, op2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4812] == 0) {
    {
    fprintf(_coverage_fout, "4812\n");
    fflush(_coverage_fout);
    ___coverage_array[4812] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result->value.lval <= 0L);
}
}
extern void __attribute__((__visibility__("default")))  _zval_dtor_func(zval *zvalue ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_dtor)(zval *zvalue ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4815] == 0) {
    {
    fprintf(_coverage_fout, "4815\n");
    fflush(_coverage_fout);
    ___coverage_array[4815] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )zvalue->type <= 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4813] == 0) {
      {
      fprintf(_coverage_fout, "4813\n");
      fflush(_coverage_fout);
      ___coverage_array[4813] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4814] == 0) {
      {
      fprintf(_coverage_fout, "4814\n");
      fflush(_coverage_fout);
      ___coverage_array[4814] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4816] == 0) {
    {
    fprintf(_coverage_fout, "4816\n");
    fflush(_coverage_fout);
    ___coverage_array[4816] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_dtor_func(zvalue);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4817] == 0) {
    {
    fprintf(_coverage_fout, "4817\n");
    fflush(_coverage_fout);
    ___coverage_array[4817] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
extern void __attribute__((__visibility__("default")))  _zval_copy_ctor_func(zval *zvalue ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_copy_ctor)(zval *zvalue ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4820] == 0) {
    {
    fprintf(_coverage_fout, "4820\n");
    fflush(_coverage_fout);
    ___coverage_array[4820] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )zvalue->type <= 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4818] == 0) {
      {
      fprintf(_coverage_fout, "4818\n");
      fflush(_coverage_fout);
      ___coverage_array[4818] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4819] == 0) {
      {
      fprintf(_coverage_fout, "4819\n");
      fflush(_coverage_fout);
      ___coverage_array[4819] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4821] == 0) {
    {
    fprintf(_coverage_fout, "4821\n");
    fflush(_coverage_fout);
    ___coverage_array[4821] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor_func(zvalue);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4822] == 0) {
    {
    fprintf(_coverage_fout, "4822\n");
    fflush(_coverage_fout);
    ___coverage_array[4822] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
extern int __attribute__((__visibility__("default")))  zval_copy_static_var(zval **p ,
                                                                            int num_args ,
                                                                            va_list args ,
                                                                            zend_hash_key *key ) ;
extern int __attribute__((__visibility__("default")))  zend_print_variable(zval *var ) ;
extern void __attribute__((__visibility__("default")))  _zval_ptr_dtor(zval **zval_ptr ) ;
extern void __attribute__((__visibility__("default")))  _zval_internal_dtor(zval *zvalue ) ;
extern void __attribute__((__visibility__("default")))  _zval_internal_ptr_dtor(zval **zvalue ) ;
extern void __attribute__((__visibility__("default")))  _zval_dtor_wrapper(zval *zvalue ) ;
extern void __attribute__((__visibility__("default")))  zval_add_ref(zval **p ) ;
extern void __attribute__((__visibility__("default")))  zend_save_error_handling(zend_error_handling *current ) ;
extern void __attribute__((__visibility__("default")))  zend_replace_error_handling(zend_error_handling_t error_handling ,
                                                                                    zend_class_entry *exception_class ,
                                                                                    zend_error_handling *current ) ;
extern void __attribute__((__visibility__("default")))  zend_restore_error_handling(zend_error_handling *saved ) ;
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  __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__,
__noreturn__)) void siglongjmp(struct __jmp_buf_tag *__env , int __val ) ;
extern struct _zend_compiler_globals  __attribute__((__visibility__("default"))) compiler_globals ;
extern int zendparse(void) ;
extern zend_executor_globals __attribute__((__visibility__("default")))  executor_globals ;
extern zend_php_scanner_globals __attribute__((__visibility__("default")))  language_scanner_globals ;
extern zend_ini_scanner_globals __attribute__((__visibility__("default")))  ini_scanner_globals ;
extern int __attribute__((__visibility__("default")))  zend_stack_init(zend_stack *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_push(zend_stack *stack ,
                                                                       void const   *element ,
                                                                       int size ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_top(zend_stack const   *stack ,
                                                                      void **element ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_del_top(zend_stack *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_int_top(zend_stack const   *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_is_empty(zend_stack const   *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_destroy(zend_stack *stack ) ;
extern void __attribute__((__visibility__("default")))  **zend_stack_base(zend_stack const   *stack ) ;
extern int __attribute__((__visibility__("default")))  zend_stack_count(zend_stack const   *stack ) ;
extern void __attribute__((__visibility__("default")))  zend_stack_apply(zend_stack *stack ,
                                                                         int type ,
                                                                         int (*apply_function)(void *element ) ) ;
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_ptr_stack_init(zend_ptr_stack *stack ) ;
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_n_push(zend_ptr_stack *stack ,
                                                                              int count 
                                                                              , ...) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_n_pop(zend_ptr_stack *stack ,
                                                                             int count 
                                                                             , ...) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_destroy(zend_ptr_stack *stack ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_apply(zend_ptr_stack *stack ,
                                                                             void (*func)(void * ) ) ;
extern void __attribute__((__visibility__("default")))  zend_ptr_stack_clean(zend_ptr_stack *stack ,
                                                                             void (*func)(void * ) ,
                                                                             zend_bool free_elements ) ;
extern int __attribute__((__visibility__("default")))  zend_ptr_stack_num_elements(zend_ptr_stack *stack ) ;
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4835] == 0) {
    {
    fprintf(_coverage_fout, "4835\n");
    fflush(_coverage_fout);
    ___coverage_array[4835] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (stack->top + 3 > stack->max) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4830] == 0) {
      {
      fprintf(_coverage_fout, "4830\n");
      fflush(_coverage_fout);
      ___coverage_array[4830] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4824] == 0) {
        {
        fprintf(_coverage_fout, "4824\n");
        fflush(_coverage_fout);
        ___coverage_array[4824] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      stack->max += 64;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4825] == 0) {
        {
        fprintf(_coverage_fout, "4825\n");
        fflush(_coverage_fout);
        ___coverage_array[4825] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (stack->top + 3 > stack->max) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4823] == 0) {
          {
          fprintf(_coverage_fout, "4823\n");
          fflush(_coverage_fout);
          ___coverage_array[4823] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4831] == 0) {
      {
      fprintf(_coverage_fout, "4831\n");
      fflush(_coverage_fout);
      ___coverage_array[4831] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (stack->persistent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4826] == 0) {
        {
        fprintf(_coverage_fout, "4826\n");
        fflush(_coverage_fout);
        ___coverage_array[4826] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __zend_realloc((void *)stack->elements,
                           sizeof(void *) * (unsigned int )stack->max);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4827] == 0) {
        {
        fprintf(_coverage_fout, "4827\n");
        fflush(_coverage_fout);
        ___coverage_array[4827] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4828] == 0) {
        {
        fprintf(_coverage_fout, "4828\n");
        fflush(_coverage_fout);
        ___coverage_array[4828] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _erealloc((void *)stack->elements,
                          sizeof(void *) * (unsigned int )stack->max, 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4829] == 0) {
        {
        fprintf(_coverage_fout, "4829\n");
        fflush(_coverage_fout);
        ___coverage_array[4829] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4832] == 0) {
      {
      fprintf(_coverage_fout, "4832\n");
      fflush(_coverage_fout);
      ___coverage_array[4832] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4833] == 0) {
      {
      fprintf(_coverage_fout, "4833\n");
      fflush(_coverage_fout);
      ___coverage_array[4833] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4834] == 0) {
      {
      fprintf(_coverage_fout, "4834\n");
      fflush(_coverage_fout);
      ___coverage_array[4834] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4836] == 0) {
    {
    fprintf(_coverage_fout, "4836\n");
    fflush(_coverage_fout);
    ___coverage_array[4836] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top += 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4837] == 0) {
    {
    fprintf(_coverage_fout, "4837\n");
    fflush(_coverage_fout);
    ___coverage_array[4837] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4838] == 0) {
    {
    fprintf(_coverage_fout, "4838\n");
    fflush(_coverage_fout);
    ___coverage_array[4838] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4839] == 0) {
    {
    fprintf(_coverage_fout, "4839\n");
    fflush(_coverage_fout);
    ___coverage_array[4839] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___2 = a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4840] == 0) {
    {
    fprintf(_coverage_fout, "4840\n");
    fflush(_coverage_fout);
    ___coverage_array[4840] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4841] == 0) {
    {
    fprintf(_coverage_fout, "4841\n");
    fflush(_coverage_fout);
    ___coverage_array[4841] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4842] == 0) {
    {
    fprintf(_coverage_fout, "4842\n");
    fflush(_coverage_fout);
    ___coverage_array[4842] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___3 = b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4843] == 0) {
    {
    fprintf(_coverage_fout, "4843\n");
    fflush(_coverage_fout);
    ___coverage_array[4843] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4844] == 0) {
    {
    fprintf(_coverage_fout, "4844\n");
    fflush(_coverage_fout);
    ___coverage_array[4844] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4845] == 0) {
    {
    fprintf(_coverage_fout, "4845\n");
    fflush(_coverage_fout);
    ___coverage_array[4845] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___4 = c;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4846] == 0) {
    {
    fprintf(_coverage_fout, "4846\n");
    fflush(_coverage_fout);
    ___coverage_array[4846] = 1;
    }
  }
  fclose(_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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4859] == 0) {
    {
    fprintf(_coverage_fout, "4859\n");
    fflush(_coverage_fout);
    ___coverage_array[4859] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (stack->top + 2 > stack->max) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4854] == 0) {
      {
      fprintf(_coverage_fout, "4854\n");
      fflush(_coverage_fout);
      ___coverage_array[4854] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4848] == 0) {
        {
        fprintf(_coverage_fout, "4848\n");
        fflush(_coverage_fout);
        ___coverage_array[4848] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      stack->max += 64;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4849] == 0) {
        {
        fprintf(_coverage_fout, "4849\n");
        fflush(_coverage_fout);
        ___coverage_array[4849] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (stack->top + 2 > stack->max) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4847] == 0) {
          {
          fprintf(_coverage_fout, "4847\n");
          fflush(_coverage_fout);
          ___coverage_array[4847] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4855] == 0) {
      {
      fprintf(_coverage_fout, "4855\n");
      fflush(_coverage_fout);
      ___coverage_array[4855] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (stack->persistent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4850] == 0) {
        {
        fprintf(_coverage_fout, "4850\n");
        fflush(_coverage_fout);
        ___coverage_array[4850] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __zend_realloc((void *)stack->elements,
                           sizeof(void *) * (unsigned int )stack->max);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4851] == 0) {
        {
        fprintf(_coverage_fout, "4851\n");
        fflush(_coverage_fout);
        ___coverage_array[4851] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4852] == 0) {
        {
        fprintf(_coverage_fout, "4852\n");
        fflush(_coverage_fout);
        ___coverage_array[4852] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _erealloc((void *)stack->elements,
                          sizeof(void *) * (unsigned int )stack->max, 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4853] == 0) {
        {
        fprintf(_coverage_fout, "4853\n");
        fflush(_coverage_fout);
        ___coverage_array[4853] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4856] == 0) {
      {
      fprintf(_coverage_fout, "4856\n");
      fflush(_coverage_fout);
      ___coverage_array[4856] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4857] == 0) {
      {
      fprintf(_coverage_fout, "4857\n");
      fflush(_coverage_fout);
      ___coverage_array[4857] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4858] == 0) {
      {
      fprintf(_coverage_fout, "4858\n");
      fflush(_coverage_fout);
      ___coverage_array[4858] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4860] == 0) {
    {
    fprintf(_coverage_fout, "4860\n");
    fflush(_coverage_fout);
    ___coverage_array[4860] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top += 2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4861] == 0) {
    {
    fprintf(_coverage_fout, "4861\n");
    fflush(_coverage_fout);
    ___coverage_array[4861] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4862] == 0) {
    {
    fprintf(_coverage_fout, "4862\n");
    fflush(_coverage_fout);
    ___coverage_array[4862] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4863] == 0) {
    {
    fprintf(_coverage_fout, "4863\n");
    fflush(_coverage_fout);
    ___coverage_array[4863] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___2 = a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4864] == 0) {
    {
    fprintf(_coverage_fout, "4864\n");
    fflush(_coverage_fout);
    ___coverage_array[4864] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4865] == 0) {
    {
    fprintf(_coverage_fout, "4865\n");
    fflush(_coverage_fout);
    ___coverage_array[4865] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4866] == 0) {
    {
    fprintf(_coverage_fout, "4866\n");
    fflush(_coverage_fout);
    ___coverage_array[4866] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___3 = b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4867] == 0) {
    {
    fprintf(_coverage_fout, "4867\n");
    fflush(_coverage_fout);
    ___coverage_array[4867] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_3_pop)(zend_ptr_stack *stack ,
                                                                                void **a ,
                                                                                void **b ,
                                                                                void **c ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4868] == 0) {
    {
    fprintf(_coverage_fout, "4868\n");
    fflush(_coverage_fout);
    ___coverage_array[4868] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4869] == 0) {
    {
    fprintf(_coverage_fout, "4869\n");
    fflush(_coverage_fout);
    ___coverage_array[4869] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *a = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4870] == 0) {
    {
    fprintf(_coverage_fout, "4870\n");
    fflush(_coverage_fout);
    ___coverage_array[4870] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4871] == 0) {
    {
    fprintf(_coverage_fout, "4871\n");
    fflush(_coverage_fout);
    ___coverage_array[4871] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *b = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4872] == 0) {
    {
    fprintf(_coverage_fout, "4872\n");
    fflush(_coverage_fout);
    ___coverage_array[4872] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4873] == 0) {
    {
    fprintf(_coverage_fout, "4873\n");
    fflush(_coverage_fout);
    ___coverage_array[4873] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *c = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4874] == 0) {
    {
    fprintf(_coverage_fout, "4874\n");
    fflush(_coverage_fout);
    ___coverage_array[4874] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top -= 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4875] == 0) {
    {
    fprintf(_coverage_fout, "4875\n");
    fflush(_coverage_fout);
    ___coverage_array[4875] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_pop)(zend_ptr_stack *stack ,
                                                                                void **a ,
                                                                                void **b ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4876] == 0) {
    {
    fprintf(_coverage_fout, "4876\n");
    fflush(_coverage_fout);
    ___coverage_array[4876] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4877] == 0) {
    {
    fprintf(_coverage_fout, "4877\n");
    fflush(_coverage_fout);
    ___coverage_array[4877] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *a = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4878] == 0) {
    {
    fprintf(_coverage_fout, "4878\n");
    fflush(_coverage_fout);
    ___coverage_array[4878] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4879] == 0) {
    {
    fprintf(_coverage_fout, "4879\n");
    fflush(_coverage_fout);
    ___coverage_array[4879] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *b = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4880] == 0) {
    {
    fprintf(_coverage_fout, "4880\n");
    fflush(_coverage_fout);
    ___coverage_array[4880] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top -= 2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4881] == 0) {
    {
    fprintf(_coverage_fout, "4881\n");
    fflush(_coverage_fout);
    ___coverage_array[4881] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4894] == 0) {
    {
    fprintf(_coverage_fout, "4894\n");
    fflush(_coverage_fout);
    ___coverage_array[4894] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (stack->top + 1 > stack->max) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4889] == 0) {
      {
      fprintf(_coverage_fout, "4889\n");
      fflush(_coverage_fout);
      ___coverage_array[4889] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4883] == 0) {
        {
        fprintf(_coverage_fout, "4883\n");
        fflush(_coverage_fout);
        ___coverage_array[4883] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      stack->max += 64;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4884] == 0) {
        {
        fprintf(_coverage_fout, "4884\n");
        fflush(_coverage_fout);
        ___coverage_array[4884] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (stack->top + 1 > stack->max) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4882] == 0) {
          {
          fprintf(_coverage_fout, "4882\n");
          fflush(_coverage_fout);
          ___coverage_array[4882] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4890] == 0) {
      {
      fprintf(_coverage_fout, "4890\n");
      fflush(_coverage_fout);
      ___coverage_array[4890] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (stack->persistent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4885] == 0) {
        {
        fprintf(_coverage_fout, "4885\n");
        fflush(_coverage_fout);
        ___coverage_array[4885] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __zend_realloc((void *)stack->elements,
                           sizeof(void *) * (unsigned int )stack->max);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4886] == 0) {
        {
        fprintf(_coverage_fout, "4886\n");
        fflush(_coverage_fout);
        ___coverage_array[4886] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4887] == 0) {
        {
        fprintf(_coverage_fout, "4887\n");
        fflush(_coverage_fout);
        ___coverage_array[4887] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _erealloc((void *)stack->elements,
                          sizeof(void *) * (unsigned int )stack->max, 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4888] == 0) {
        {
        fprintf(_coverage_fout, "4888\n");
        fflush(_coverage_fout);
        ___coverage_array[4888] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4891] == 0) {
      {
      fprintf(_coverage_fout, "4891\n");
      fflush(_coverage_fout);
      ___coverage_array[4891] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4892] == 0) {
      {
      fprintf(_coverage_fout, "4892\n");
      fflush(_coverage_fout);
      ___coverage_array[4892] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4893] == 0) {
      {
      fprintf(_coverage_fout, "4893\n");
      fflush(_coverage_fout);
      ___coverage_array[4893] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4895] == 0) {
    {
    fprintf(_coverage_fout, "4895\n");
    fflush(_coverage_fout);
    ___coverage_array[4895] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4896] == 0) {
    {
    fprintf(_coverage_fout, "4896\n");
    fflush(_coverage_fout);
    ___coverage_array[4896] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4897] == 0) {
    {
    fprintf(_coverage_fout, "4897\n");
    fflush(_coverage_fout);
    ___coverage_array[4897] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4898] == 0) {
    {
    fprintf(_coverage_fout, "4898\n");
    fflush(_coverage_fout);
    ___coverage_array[4898] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___2 = ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4899] == 0) {
    {
    fprintf(_coverage_fout, "4899\n");
    fflush(_coverage_fout);
    ___coverage_array[4899] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void *( __attribute__((__always_inline__)) zend_ptr_stack_pop)(zend_ptr_stack *stack ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4900] == 0) {
    {
    fprintf(_coverage_fout, "4900\n");
    fflush(_coverage_fout);
    ___coverage_array[4900] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4901] == 0) {
    {
    fprintf(_coverage_fout, "4901\n");
    fflush(_coverage_fout);
    ___coverage_array[4901] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4902] == 0) {
    {
    fprintf(_coverage_fout, "4902\n");
    fflush(_coverage_fout);
    ___coverage_array[4902] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (*(stack->top_element));
}
}
extern void __attribute__((__visibility__("default")))  zend_object_std_init(zend_object *object ,
                                                                             zend_class_entry *ce ) ;
extern void __attribute__((__visibility__("default")))  zend_object_std_dtor(zend_object *object ) ;
extern zend_object_value __attribute__((__visibility__("default")))  zend_objects_new(zend_object **object ,
                                                                                      zend_class_entry *class_type ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_destroy_object(zend_object *object ,
                                                                                    zend_object_handle handle ) ;
extern zend_object __attribute__((__visibility__("default")))  *zend_objects_get_address(zval const   *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 zend_object_value __attribute__((__visibility__("default")))  zend_objects_clone_obj(zval *object ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_free_object_storage(zend_object *object ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_init(zend_objects_store *objects ,
                                                                                zend_uint init_size ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_call_destructors(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_destroy(zend_objects_store *objects ) ;
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_add_ref(zval *object ) ;
extern void __attribute__((__visibility__("default")))  zend_objects_store_del_ref(zval *object ) ;
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_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 ) 
{ 

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

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4911] == 0) {
    {
    fprintf(_coverage_fout, "4911\n");
    fflush(_coverage_fout);
    ___coverage_array[4911] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )p != (unsigned int )executor_globals.uninitialized_zval_ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4909] == 0) {
      {
      fprintf(_coverage_fout, "4909\n");
      fflush(_coverage_fout);
      ___coverage_array[4909] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4907] == 0) {
        {
        fprintf(_coverage_fout, "4907\n");
        fflush(_coverage_fout);
        ___coverage_array[4907] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)p)->u.buffered & 4294967292UL)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4905] == 0) {
          {
          fprintf(_coverage_fout, "4905\n");
          fflush(_coverage_fout);
          ___coverage_array[4905] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        gc_remove_zval_from_buffer(p);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4906] == 0) {
          {
          fprintf(_coverage_fout, "4906\n");
          fflush(_coverage_fout);
          ___coverage_array[4906] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4908] == 0) {
        {
        fprintf(_coverage_fout, "4908\n");
        fflush(_coverage_fout);
        ___coverage_array[4908] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _efree((void *)p);
      break;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4910] == 0) {
      {
      fprintf(_coverage_fout, "4910\n");
      fflush(_coverage_fout);
      ___coverage_array[4910] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4912] == 0) {
    {
    fprintf(_coverage_fout, "4912\n");
    fflush(_coverage_fout);
    ___coverage_array[4912] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
extern int __attribute__((__visibility__("default")))  zend_lookup_class(char const   *name ,
                                                                         int name_length ,
                                                                         zend_class_entry ***ce ) ;
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 ) ;
extern int __attribute__((__visibility__("default")))  zend_eval_string(char *str ,
                                                                        zval *retval_ptr ,
                                                                        char *string_name ) ;
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_ex(char *str ,
                                                                           zval *retval_ptr ,
                                                                           char *string_name ,
                                                                           int handle_exceptions ) ;
extern int __attribute__((__visibility__("default")))  zend_eval_stringl_ex(char *str ,
                                                                            int str_len ,
                                                                            zval *retval_ptr ,
                                                                            char *string_name ,
                                                                            int handle_exceptions ) ;
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_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 const   *given_kind ) ;
__inline static void ( __attribute__((__always_inline__)) i_zval_ptr_dtor)(zval *zval_ptr ) 
{ zend_uint tmp ;
  zend_uint tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4925] == 0) {
    {
    fprintf(_coverage_fout, "4925\n");
    fflush(_coverage_fout);
    ___coverage_array[4925] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zval_delref_p(zval_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4926] == 0) {
    {
    fprintf(_coverage_fout, "4926\n");
    fflush(_coverage_fout);
    ___coverage_array[4926] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4915] == 0) {
      {
      fprintf(_coverage_fout, "4915\n");
      fflush(_coverage_fout);
      ___coverage_array[4915] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = zval_refcount_p(zval_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4916] == 0) {
      {
      fprintf(_coverage_fout, "4916\n");
      fflush(_coverage_fout);
      ___coverage_array[4916] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp == 1U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4913] == 0) {
        {
        fprintf(_coverage_fout, "4913\n");
        fflush(_coverage_fout);
        ___coverage_array[4913] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_unset_isref_p(zval_ptr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4914] == 0) {
        {
        fprintf(_coverage_fout, "4914\n");
        fflush(_coverage_fout);
        ___coverage_array[4914] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4917] == 0) {
      {
      fprintf(_coverage_fout, "4917\n");
      fflush(_coverage_fout);
      ___coverage_array[4917] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    gc_zval_check_possible_root(zval_ptr);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4924] == 0) {
      {
      fprintf(_coverage_fout, "4924\n");
      fflush(_coverage_fout);
      ___coverage_array[4924] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )zval_ptr != (unsigned int )(& executor_globals.uninitialized_zval)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4920] == 0) {
        {
        fprintf(_coverage_fout, "4920\n");
        fflush(_coverage_fout);
        ___coverage_array[4920] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)zval_ptr)->u.buffered & 4294967292UL)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4918] == 0) {
          {
          fprintf(_coverage_fout, "4918\n");
          fflush(_coverage_fout);
          ___coverage_array[4918] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        gc_remove_zval_from_buffer(zval_ptr);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4919] == 0) {
          {
          fprintf(_coverage_fout, "4919\n");
          fflush(_coverage_fout);
          ___coverage_array[4919] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4921] == 0) {
        {
        fprintf(_coverage_fout, "4921\n");
        fflush(_coverage_fout);
        ___coverage_array[4921] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _zval_dtor(zval_ptr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4922] == 0) {
        {
        fprintf(_coverage_fout, "4922\n");
        fflush(_coverage_fout);
        ___coverage_array[4922] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _efree((void *)zval_ptr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4923] == 0) {
        {
        fprintf(_coverage_fout, "4923\n");
        fflush(_coverage_fout);
        ___coverage_array[4923] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4927] == 0) {
    {
    fprintf(_coverage_fout, "4927\n");
    fflush(_coverage_fout);
    ___coverage_array[4927] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__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 ;

  {
  switch ((int )op->type) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4957] == 0) {
    {
    fprintf(_coverage_fout, "4957\n");
    fflush(_coverage_fout);
    ___coverage_array[4957] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 0: 
  result = 0;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4958] == 0) {
    {
    fprintf(_coverage_fout, "4958\n");
    fflush(_coverage_fout);
    ___coverage_array[4958] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  case 3: 
  case 7: 
  if (op->value.lval) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4928] == 0) {
      {
      fprintf(_coverage_fout, "4928\n");
      fflush(_coverage_fout);
      ___coverage_array[4928] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4929] == 0) {
      {
      fprintf(_coverage_fout, "4929\n");
      fflush(_coverage_fout);
      ___coverage_array[4929] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4959] == 0) {
    {
    fprintf(_coverage_fout, "4959\n");
    fflush(_coverage_fout);
    ___coverage_array[4959] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  if (op->value.dval) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4930] == 0) {
      {
      fprintf(_coverage_fout, "4930\n");
      fflush(_coverage_fout);
      ___coverage_array[4930] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4931] == 0) {
      {
      fprintf(_coverage_fout, "4931\n");
      fflush(_coverage_fout);
      ___coverage_array[4931] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4960] == 0) {
    {
    fprintf(_coverage_fout, "4960\n");
    fflush(_coverage_fout);
    ___coverage_array[4960] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 6: 
  if (op->value.str.len == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4932] == 0) {
      {
      fprintf(_coverage_fout, "4932\n");
      fflush(_coverage_fout);
      ___coverage_array[4932] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4937] == 0) {
      {
      fprintf(_coverage_fout, "4937\n");
      fflush(_coverage_fout);
      ___coverage_array[4937] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (op->value.str.len == 1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4935] == 0) {
        {
        fprintf(_coverage_fout, "4935\n");
        fflush(_coverage_fout);
        ___coverage_array[4935] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*(op->value.str.val + 0) == 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4933] == 0) {
          {
          fprintf(_coverage_fout, "4933\n");
          fflush(_coverage_fout);
          ___coverage_array[4933] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result = 0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4934] == 0) {
          {
          fprintf(_coverage_fout, "4934\n");
          fflush(_coverage_fout);
          ___coverage_array[4934] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result = 1;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4936] == 0) {
        {
        fprintf(_coverage_fout, "4936\n");
        fflush(_coverage_fout);
        ___coverage_array[4936] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = 1;
    }
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4961] == 0) {
    {
    fprintf(_coverage_fout, "4961\n");
    fflush(_coverage_fout);
    ___coverage_array[4961] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 4: 
  tmp___0 = zend_hash_num_elements((HashTable const   *)op->value.ht);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4962] == 0) {
    {
    fprintf(_coverage_fout, "4962\n");
    fflush(_coverage_fout);
    ___coverage_array[4962] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4938] == 0) {
      {
      fprintf(_coverage_fout, "4938\n");
      fflush(_coverage_fout);
      ___coverage_array[4938] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4939] == 0) {
      {
      fprintf(_coverage_fout, "4939\n");
      fflush(_coverage_fout);
      ___coverage_array[4939] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4963] == 0) {
    {
    fprintf(_coverage_fout, "4963\n");
    fflush(_coverage_fout);
    ___coverage_array[4963] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 5: 
  if ((int )op->type == 5) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4955] == 0) {
      {
      fprintf(_coverage_fout, "4955\n");
      fflush(_coverage_fout);
      ___coverage_array[4955] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )(op->value.obj.handlers)->get_class_entry != (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4953] == 0) {
        {
        fprintf(_coverage_fout, "4953\n");
        fflush(_coverage_fout);
        ___coverage_array[4953] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((op->value.obj.handlers)->cast_object) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4942] == 0) {
          {
          fprintf(_coverage_fout, "4942\n");
          fflush(_coverage_fout);
          ___coverage_array[4942] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___2 = (*((op->value.obj.handlers)->cast_object))(op, & tmp___1, 3);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4943] == 0) {
          {
          fprintf(_coverage_fout, "4943\n");
          fflush(_coverage_fout);
          ___coverage_array[4943] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___2 == 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4940] == 0) {
            {
            fprintf(_coverage_fout, "4940\n");
            fflush(_coverage_fout);
            ___coverage_array[4940] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result = (int )tmp___1.value.lval;
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4941] == 0) {
            {
            fprintf(_coverage_fout, "4941\n");
            fflush(_coverage_fout);
            ___coverage_array[4941] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[4952] == 0) {
          {
          fprintf(_coverage_fout, "4952\n");
          fflush(_coverage_fout);
          ___coverage_array[4952] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((op->value.obj.handlers)->get) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4948] == 0) {
            {
            fprintf(_coverage_fout, "4948\n");
            fflush(_coverage_fout);
            ___coverage_array[4948] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___4 = (*((op->value.obj.handlers)->get))(op);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4949] == 0) {
            {
            fprintf(_coverage_fout, "4949\n");
            fflush(_coverage_fout);
            ___coverage_array[4949] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___3 = tmp___4;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4950] == 0) {
            {
            fprintf(_coverage_fout, "4950\n");
            fflush(_coverage_fout);
            ___coverage_array[4950] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int )tmp___3->type != 5) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4944] == 0) {
              {
              fprintf(_coverage_fout, "4944\n");
              fflush(_coverage_fout);
              ___coverage_array[4944] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            convert_to_boolean(tmp___3);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4945] == 0) {
              {
              fprintf(_coverage_fout, "4945\n");
              fflush(_coverage_fout);
              ___coverage_array[4945] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            result = (int )tmp___3->value.lval;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4946] == 0) {
              {
              fprintf(_coverage_fout, "4946\n");
              fflush(_coverage_fout);
              ___coverage_array[4946] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_ptr_dtor(& tmp___3);
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4947] == 0) {
              {
              fprintf(_coverage_fout, "4947\n");
              fflush(_coverage_fout);
              ___coverage_array[4947] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4951] == 0) {
            {
            fprintf(_coverage_fout, "4951\n");
            fflush(_coverage_fout);
            ___coverage_array[4951] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4954] == 0) {
        {
        fprintf(_coverage_fout, "4954\n");
        fflush(_coverage_fout);
        ___coverage_array[4954] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4956] == 0) {
      {
      fprintf(_coverage_fout, "4956\n");
      fflush(_coverage_fout);
      ___coverage_array[4956] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4964] == 0) {
    {
    fprintf(_coverage_fout, "4964\n");
    fflush(_coverage_fout);
    ___coverage_array[4964] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  result = 1;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4965] == 0) {
    {
    fprintf(_coverage_fout, "4965\n");
    fflush(_coverage_fout);
    ___coverage_array[4965] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  result = 0;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4966] == 0) {
    {
    fprintf(_coverage_fout, "4966\n");
    fflush(_coverage_fout);
    ___coverage_array[4966] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result);
}
}
extern int __attribute__((__visibility__("default")))  zval_update_constant(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_no_inline_change(zval **pp ,
                                                                                             void *arg ) ;
extern int __attribute__((__visibility__("default")))  zval_update_constant_ex(zval **pp ,
                                                                               void *arg ,
                                                                               zend_class_entry *scope ) ;
__inline static zend_vm_stack ( __attribute__((__always_inline__)) zend_vm_stack_new_page)(int count ) 
{ zend_vm_stack page ;
  void __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4967] == 0) {
    {
    fprintf(_coverage_fout, "4967\n");
    fflush(_coverage_fout);
    ___coverage_array[4967] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc((((sizeof(*page) + 4U) - 1U) & 4294967292U) + sizeof(void *) * (unsigned int )count);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4968] == 0) {
    {
    fprintf(_coverage_fout, "4968\n");
    fflush(_coverage_fout);
    ___coverage_array[4968] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page = (struct _zend_vm_stack *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4969] == 0) {
    {
    fprintf(_coverage_fout, "4969\n");
    fflush(_coverage_fout);
    ___coverage_array[4969] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page->top = (void **)((char *)page + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4970] == 0) {
    {
    fprintf(_coverage_fout, "4970\n");
    fflush(_coverage_fout);
    ___coverage_array[4970] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page->end = page->top + count;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4971] == 0) {
    {
    fprintf(_coverage_fout, "4971\n");
    fflush(_coverage_fout);
    ___coverage_array[4971] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page->prev = (struct _zend_vm_stack *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4972] == 0) {
    {
    fprintf(_coverage_fout, "4972\n");
    fflush(_coverage_fout);
    ___coverage_array[4972] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (page);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_init)(void) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4973] == 0) {
    {
    fprintf(_coverage_fout, "4973\n");
    fflush(_coverage_fout);
    ___coverage_array[4973] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  executor_globals.argument_stack = zend_vm_stack_new_page(16368);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4974] == 0) {
    {
    fprintf(_coverage_fout, "4974\n");
    fflush(_coverage_fout);
    ___coverage_array[4974] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_destroy)(void) 
{ zend_vm_stack stack ;
  zend_vm_stack p ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4980] == 0) {
    {
    fprintf(_coverage_fout, "4980\n");
    fflush(_coverage_fout);
    ___coverage_array[4980] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack = executor_globals.argument_stack;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4981] == 0) {
    {
    fprintf(_coverage_fout, "4981\n");
    fflush(_coverage_fout);
    ___coverage_array[4981] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4976] == 0) {
      {
      fprintf(_coverage_fout, "4976\n");
      fflush(_coverage_fout);
      ___coverage_array[4976] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )stack != (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4975] == 0) {
        {
        fprintf(_coverage_fout, "4975\n");
        fflush(_coverage_fout);
        ___coverage_array[4975] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4977] == 0) {
      {
      fprintf(_coverage_fout, "4977\n");
      fflush(_coverage_fout);
      ___coverage_array[4977] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = stack->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4978] == 0) {
      {
      fprintf(_coverage_fout, "4978\n");
      fflush(_coverage_fout);
      ___coverage_array[4978] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)stack);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4979] == 0) {
      {
      fprintf(_coverage_fout, "4979\n");
      fflush(_coverage_fout);
      ___coverage_array[4979] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack = p;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4982] == 0) {
    {
    fprintf(_coverage_fout, "4982\n");
    fflush(_coverage_fout);
    ___coverage_array[4982] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_extend)(int count ) 
{ zend_vm_stack p ;
  int tmp ;
  zend_vm_stack tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4985] == 0) {
    {
    fprintf(_coverage_fout, "4985\n");
    fflush(_coverage_fout);
    ___coverage_array[4985] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (count >= 16368) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4983] == 0) {
      {
      fprintf(_coverage_fout, "4983\n");
      fflush(_coverage_fout);
      ___coverage_array[4983] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = count;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4984] == 0) {
      {
      fprintf(_coverage_fout, "4984\n");
      fflush(_coverage_fout);
      ___coverage_array[4984] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = 16368;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4986] == 0) {
    {
    fprintf(_coverage_fout, "4986\n");
    fflush(_coverage_fout);
    ___coverage_array[4986] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_vm_stack_new_page(tmp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4987] == 0) {
    {
    fprintf(_coverage_fout, "4987\n");
    fflush(_coverage_fout);
    ___coverage_array[4987] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4988] == 0) {
    {
    fprintf(_coverage_fout, "4988\n");
    fflush(_coverage_fout);
    ___coverage_array[4988] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p->prev = executor_globals.argument_stack;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4989] == 0) {
    {
    fprintf(_coverage_fout, "4989\n");
    fflush(_coverage_fout);
    ___coverage_array[4989] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  executor_globals.argument_stack = p;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4990] == 0) {
    {
    fprintf(_coverage_fout, "4990\n");
    fflush(_coverage_fout);
    ___coverage_array[4990] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void **( __attribute__((__always_inline__)) zend_vm_stack_top)(void) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4991] == 0) {
    {
    fprintf(_coverage_fout, "4991\n");
    fflush(_coverage_fout);
    ___coverage_array[4991] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((executor_globals.argument_stack)->top);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push)(void *ptr ) 
{ long tmp ;
  void **tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4996] == 0) {
    {
    fprintf(_coverage_fout, "4996\n");
    fflush(_coverage_fout);
    ___coverage_array[4996] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4994] == 0) {
      {
      fprintf(_coverage_fout, "4994\n");
      fflush(_coverage_fout);
      ___coverage_array[4994] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = __builtin_expect((long )(1 > (executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top),
                           0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[4995] == 0) {
      {
      fprintf(_coverage_fout, "4995\n");
      fflush(_coverage_fout);
      ___coverage_array[4995] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4992] == 0) {
        {
        fprintf(_coverage_fout, "4992\n");
        fflush(_coverage_fout);
        ___coverage_array[4992] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_vm_stack_extend(1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[4993] == 0) {
        {
        fprintf(_coverage_fout, "4993\n");
        fflush(_coverage_fout);
        ___coverage_array[4993] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4997] == 0) {
    {
    fprintf(_coverage_fout, "4997\n");
    fflush(_coverage_fout);
    ___coverage_array[4997] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = (executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4998] == 0) {
    {
    fprintf(_coverage_fout, "4998\n");
    fflush(_coverage_fout);
    ___coverage_array[4998] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[4999] == 0) {
    {
    fprintf(_coverage_fout, "4999\n");
    fflush(_coverage_fout);
    ___coverage_array[4999] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___0 = ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5000] == 0) {
    {
    fprintf(_coverage_fout, "5000\n");
    fflush(_coverage_fout);
    ___coverage_array[5000] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push_nocheck)(void *ptr ) 
{ void **tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5001] == 0) {
    {
    fprintf(_coverage_fout, "5001\n");
    fflush(_coverage_fout);
    ___coverage_array[5001] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5002] == 0) {
    {
    fprintf(_coverage_fout, "5002\n");
    fflush(_coverage_fout);
    ___coverage_array[5002] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5003] == 0) {
    {
    fprintf(_coverage_fout, "5003\n");
    fflush(_coverage_fout);
    ___coverage_array[5003] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp = ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5004] == 0) {
    {
    fprintf(_coverage_fout, "5004\n");
    fflush(_coverage_fout);
    ___coverage_array[5004] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void *( __attribute__((__always_inline__)) zend_vm_stack_pop)(void) 
{ void *el ;
  zend_vm_stack p ;
  long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5009] == 0) {
    {
    fprintf(_coverage_fout, "5009\n");
    fflush(_coverage_fout);
    ___coverage_array[5009] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5010] == 0) {
    {
    fprintf(_coverage_fout, "5010\n");
    fflush(_coverage_fout);
    ___coverage_array[5010] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  el = *((executor_globals.argument_stack)->top);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5011] == 0) {
    {
    fprintf(_coverage_fout, "5011\n");
    fflush(_coverage_fout);
    ___coverage_array[5011] = 1;
    }
  }
  fclose(_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);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5012] == 0) {
    {
    fprintf(_coverage_fout, "5012\n");
    fflush(_coverage_fout);
    ___coverage_array[5012] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5005] == 0) {
      {
      fprintf(_coverage_fout, "5005\n");
      fflush(_coverage_fout);
      ___coverage_array[5005] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5006] == 0) {
      {
      fprintf(_coverage_fout, "5006\n");
      fflush(_coverage_fout);
      ___coverage_array[5006] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5007] == 0) {
      {
      fprintf(_coverage_fout, "5007\n");
      fflush(_coverage_fout);
      ___coverage_array[5007] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5008] == 0) {
      {
      fprintf(_coverage_fout, "5008\n");
      fflush(_coverage_fout);
      ___coverage_array[5008] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5013] == 0) {
    {
    fprintf(_coverage_fout, "5013\n");
    fflush(_coverage_fout);
    ___coverage_array[5013] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (el);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5027] == 0) {
    {
    fprintf(_coverage_fout, "5027\n");
    fflush(_coverage_fout);
    ___coverage_array[5027] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  size = (size + (sizeof(void *) - 1U)) / sizeof(void *);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5028] == 0) {
    {
    fprintf(_coverage_fout, "5028\n");
    fflush(_coverage_fout);
    ___coverage_array[5028] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (4U > sizeof(void *)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5019] == 0) {
      {
      fprintf(_coverage_fout, "5019\n");
      fflush(_coverage_fout);
      ___coverage_array[5019] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    extra = (int )((4UL - ((unsigned long )(executor_globals.argument_stack)->top & 3UL)) / (unsigned long )sizeof(void *));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5020] == 0) {
      {
      fprintf(_coverage_fout, "5020\n");
      fflush(_coverage_fout);
      ___coverage_array[5020] = 1;
      }
    }
    fclose(_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);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5021] == 0) {
      {
      fprintf(_coverage_fout, "5021\n");
      fflush(_coverage_fout);
      ___coverage_array[5021] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5014] == 0) {
        {
        fprintf(_coverage_fout, "5014\n");
        fflush(_coverage_fout);
        ___coverage_array[5014] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_vm_stack_extend((int )size);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5015] == 0) {
        {
        fprintf(_coverage_fout, "5015\n");
        fflush(_coverage_fout);
        ___coverage_array[5015] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      old_top = (executor_globals.argument_stack)->top;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5016] == 0) {
        {
        fprintf(_coverage_fout, "5016\n");
        fflush(_coverage_fout);
        ___coverage_array[5016] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += extra;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5017] == 0) {
        {
        fprintf(_coverage_fout, "5017\n");
        fflush(_coverage_fout);
        ___coverage_array[5017] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *((executor_globals.argument_stack)->top) = (void *)old_top;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5018] == 0) {
        {
        fprintf(_coverage_fout, "5018\n");
        fflush(_coverage_fout);
        ___coverage_array[5018] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += (((sizeof(void *) + 4U) - 1U) & 4294967292U) / sizeof(void *);
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5026] == 0) {
      {
      fprintf(_coverage_fout, "5026\n");
      fflush(_coverage_fout);
      ___coverage_array[5026] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5024] == 0) {
        {
        fprintf(_coverage_fout, "5024\n");
        fflush(_coverage_fout);
        ___coverage_array[5024] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = __builtin_expect((long )((int )size > (executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top),
                                 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5025] == 0) {
        {
        fprintf(_coverage_fout, "5025\n");
        fflush(_coverage_fout);
        ___coverage_array[5025] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5022] == 0) {
          {
          fprintf(_coverage_fout, "5022\n");
          fflush(_coverage_fout);
          ___coverage_array[5022] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_vm_stack_extend((int )size);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5023] == 0) {
          {
          fprintf(_coverage_fout, "5023\n");
          fflush(_coverage_fout);
          ___coverage_array[5023] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5029] == 0) {
    {
    fprintf(_coverage_fout, "5029\n");
    fflush(_coverage_fout);
    ___coverage_array[5029] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ret = (void *)(executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5030] == 0) {
    {
    fprintf(_coverage_fout, "5030\n");
    fflush(_coverage_fout);
    ___coverage_array[5030] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (executor_globals.argument_stack)->top += size;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5031] == 0) {
    {
    fprintf(_coverage_fout, "5031\n");
    fflush(_coverage_fout);
    ___coverage_array[5031] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (ret);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free_int)(void *ptr ) 
{ zend_vm_stack p ;
  long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5036] == 0) {
    {
    fprintf(_coverage_fout, "5036\n");
    fflush(_coverage_fout);
    ___coverage_array[5036] = 1;
    }
  }
  fclose(_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);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5037] == 0) {
    {
    fprintf(_coverage_fout, "5037\n");
    fflush(_coverage_fout);
    ___coverage_array[5037] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5032] == 0) {
      {
      fprintf(_coverage_fout, "5032\n");
      fflush(_coverage_fout);
      ___coverage_array[5032] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5033] == 0) {
      {
      fprintf(_coverage_fout, "5033\n");
      fflush(_coverage_fout);
      ___coverage_array[5033] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5034] == 0) {
      {
      fprintf(_coverage_fout, "5034\n");
      fflush(_coverage_fout);
      ___coverage_array[5034] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5035] == 0) {
      {
      fprintf(_coverage_fout, "5035\n");
      fflush(_coverage_fout);
      ___coverage_array[5035] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (executor_globals.argument_stack)->top = (void **)ptr;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5038] == 0) {
    {
    fprintf(_coverage_fout, "5038\n");
    fflush(_coverage_fout);
    ___coverage_array[5038] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free)(void *ptr ) 
{ zend_vm_stack p ;
  long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5046] == 0) {
    {
    fprintf(_coverage_fout, "5046\n");
    fflush(_coverage_fout);
    ___coverage_array[5046] = 1;
    }
  }
  fclose(_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);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5047] == 0) {
    {
    fprintf(_coverage_fout, "5047\n");
    fflush(_coverage_fout);
    ___coverage_array[5047] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5039] == 0) {
      {
      fprintf(_coverage_fout, "5039\n");
      fflush(_coverage_fout);
      ___coverage_array[5039] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5040] == 0) {
      {
      fprintf(_coverage_fout, "5040\n");
      fflush(_coverage_fout);
      ___coverage_array[5040] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5041] == 0) {
      {
      fprintf(_coverage_fout, "5041\n");
      fflush(_coverage_fout);
      ___coverage_array[5041] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5045] == 0) {
      {
      fprintf(_coverage_fout, "5045\n");
      fflush(_coverage_fout);
      ___coverage_array[5045] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (4U > sizeof(void *)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5042] == 0) {
        {
        fprintf(_coverage_fout, "5042\n");
        fflush(_coverage_fout);
        ___coverage_array[5042] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ptr = (void *)((char *)ptr - (((sizeof(void *) + 4U) - 1U) & 4294967292U));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5043] == 0) {
        {
        fprintf(_coverage_fout, "5043\n");
        fflush(_coverage_fout);
        ___coverage_array[5043] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top = *((void ***)ptr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5044] == 0) {
        {
        fprintf(_coverage_fout, "5044\n");
        fflush(_coverage_fout);
        ___coverage_array[5044] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top = (void **)ptr;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5048] == 0) {
    {
    fprintf(_coverage_fout, "5048\n");
    fflush(_coverage_fout);
    ___coverage_array[5048] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5074] == 0) {
    {
    fprintf(_coverage_fout, "5074\n");
    fflush(_coverage_fout);
    ___coverage_array[5074] = 1;
    }
  }
  fclose(_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);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5075] == 0) {
    {
    fprintf(_coverage_fout, "5075\n");
    fflush(_coverage_fout);
    ___coverage_array[5075] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5072] == 0) {
      {
      fprintf(_coverage_fout, "5072\n");
      fflush(_coverage_fout);
      ___coverage_array[5072] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((unsigned int )(executor_globals.argument_stack)->top == (unsigned int )(executor_globals.argument_stack)->end),
                               0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5073] == 0) {
      {
      fprintf(_coverage_fout, "5073\n");
      fflush(_coverage_fout);
      ___coverage_array[5073] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5063] == 0) {
        {
        fprintf(_coverage_fout, "5063\n");
        fflush(_coverage_fout);
        ___coverage_array[5063] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L: /* CIL Label */ 
      p = executor_globals.argument_stack;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5064] == 0) {
        {
        fprintf(_coverage_fout, "5064\n");
        fflush(_coverage_fout);
        ___coverage_array[5064] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_vm_stack_extend(count + 1);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5065] == 0) {
        {
        fprintf(_coverage_fout, "5065\n");
        fflush(_coverage_fout);
        ___coverage_array[5065] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += count;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5066] == 0) {
        {
        fprintf(_coverage_fout, "5066\n");
        fflush(_coverage_fout);
        ___coverage_array[5066] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *((executor_globals.argument_stack)->top) = (void *)((unsigned long )count);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5067] == 0) {
        {
        fprintf(_coverage_fout, "5067\n");
        fflush(_coverage_fout);
        ___coverage_array[5067] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5055] == 0) {
          {
          fprintf(_coverage_fout, "5055\n");
          fflush(_coverage_fout);
          ___coverage_array[5055] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = count;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5056] == 0) {
          {
          fprintf(_coverage_fout, "5056\n");
          fflush(_coverage_fout);
          ___coverage_array[5056] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        count --;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5057] == 0) {
          {
          fprintf(_coverage_fout, "5057\n");
          fflush(_coverage_fout);
          ___coverage_array[5057] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___0 > 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5049] == 0) {
            {
            fprintf(_coverage_fout, "5049\n");
            fflush(_coverage_fout);
            ___coverage_array[5049] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5058] == 0) {
          {
          fprintf(_coverage_fout, "5058\n");
          fflush(_coverage_fout);
          ___coverage_array[5058] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        (p->top) --;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5059] == 0) {
          {
          fprintf(_coverage_fout, "5059\n");
          fflush(_coverage_fout);
          ___coverage_array[5059] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        data = *(p->top);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5060] == 0) {
          {
          fprintf(_coverage_fout, "5060\n");
          fflush(_coverage_fout);
          ___coverage_array[5060] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __builtin_expect((long )((unsigned int )p->top == (unsigned int )((void **)((char *)p + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)))),
                               0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5061] == 0) {
          {
          fprintf(_coverage_fout, "5061\n");
          fflush(_coverage_fout);
          ___coverage_array[5061] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5050] == 0) {
            {
            fprintf(_coverage_fout, "5050\n");
            fflush(_coverage_fout);
            ___coverage_array[5050] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          r = p;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5051] == 0) {
            {
            fprintf(_coverage_fout, "5051\n");
            fflush(_coverage_fout);
            ___coverage_array[5051] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          (executor_globals.argument_stack)->prev = p->prev;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5052] == 0) {
            {
            fprintf(_coverage_fout, "5052\n");
            fflush(_coverage_fout);
            ___coverage_array[5052] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          p = p->prev;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5053] == 0) {
            {
            fprintf(_coverage_fout, "5053\n");
            fflush(_coverage_fout);
            ___coverage_array[5053] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _efree((void *)r);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5054] == 0) {
            {
            fprintf(_coverage_fout, "5054\n");
            fflush(_coverage_fout);
            ___coverage_array[5054] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5062] == 0) {
          {
          fprintf(_coverage_fout, "5062\n");
          fflush(_coverage_fout);
          ___coverage_array[5062] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *((void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)) + count) = data;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5068] == 0) {
        {
        fprintf(_coverage_fout, "5068\n");
        fflush(_coverage_fout);
        ___coverage_array[5068] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (executor_globals.argument_stack)->top;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5069] == 0) {
        {
        fprintf(_coverage_fout, "5069\n");
        fflush(_coverage_fout);
        ___coverage_array[5069] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((executor_globals.argument_stack)->top) ++;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5070] == 0) {
        {
        fprintf(_coverage_fout, "5070\n");
        fflush(_coverage_fout);
        ___coverage_array[5070] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (tmp___1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5071] == 0) {
        {
        fprintf(_coverage_fout, "5071\n");
        fflush(_coverage_fout);
        ___coverage_array[5071] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5076] == 0) {
    {
    fprintf(_coverage_fout, "5076\n");
    fflush(_coverage_fout);
    ___coverage_array[5076] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *((executor_globals.argument_stack)->top) = (void *)((unsigned long )count);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5077] == 0) {
    {
    fprintf(_coverage_fout, "5077\n");
    fflush(_coverage_fout);
    ___coverage_array[5077] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = (executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5078] == 0) {
    {
    fprintf(_coverage_fout, "5078\n");
    fflush(_coverage_fout);
    ___coverage_array[5078] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5079] == 0) {
    {
    fprintf(_coverage_fout, "5079\n");
    fflush(_coverage_fout);
    ___coverage_array[5079] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___4);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_clear_multiple)(void) 
{ void **p ;
  int delete_count ;
  zval *q ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5087] == 0) {
    {
    fprintf(_coverage_fout, "5087\n");
    fflush(_coverage_fout);
    ___coverage_array[5087] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = (executor_globals.argument_stack)->top - 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5088] == 0) {
    {
    fprintf(_coverage_fout, "5088\n");
    fflush(_coverage_fout);
    ___coverage_array[5088] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  delete_count = (int )((unsigned long )*p);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5089] == 0) {
    {
    fprintf(_coverage_fout, "5089\n");
    fflush(_coverage_fout);
    ___coverage_array[5089] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5081] == 0) {
      {
      fprintf(_coverage_fout, "5081\n");
      fflush(_coverage_fout);
      ___coverage_array[5081] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    delete_count --;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5082] == 0) {
      {
      fprintf(_coverage_fout, "5082\n");
      fflush(_coverage_fout);
      ___coverage_array[5082] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (delete_count >= 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5080] == 0) {
        {
        fprintf(_coverage_fout, "5080\n");
        fflush(_coverage_fout);
        ___coverage_array[5080] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5083] == 0) {
      {
      fprintf(_coverage_fout, "5083\n");
      fflush(_coverage_fout);
      ___coverage_array[5083] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p --;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5084] == 0) {
      {
      fprintf(_coverage_fout, "5084\n");
      fflush(_coverage_fout);
      ___coverage_array[5084] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    q = *((zval **)p);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5085] == 0) {
      {
      fprintf(_coverage_fout, "5085\n");
      fflush(_coverage_fout);
      ___coverage_array[5085] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *p = (void *)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5086] == 0) {
      {
      fprintf(_coverage_fout, "5086\n");
      fflush(_coverage_fout);
      ___coverage_array[5086] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i_zval_ptr_dtor(q);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5090] == 0) {
    {
    fprintf(_coverage_fout, "5090\n");
    fflush(_coverage_fout);
    ___coverage_array[5090] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_vm_stack_free_int((void *)p);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5091] == 0) {
    {
    fprintf(_coverage_fout, "5091\n");
    fflush(_coverage_fout);
    ___coverage_array[5091] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static zval **( __attribute__((__always_inline__)) zend_vm_stack_get_arg)(int requested_arg ) 
{ void **p ;
  int arg_count ;
  long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5094] == 0) {
    {
    fprintf(_coverage_fout, "5094\n");
    fflush(_coverage_fout);
    ___coverage_array[5094] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = ((executor_globals.current_execute_data)->prev_execute_data)->function_state.arguments;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5095] == 0) {
    {
    fprintf(_coverage_fout, "5095\n");
    fflush(_coverage_fout);
    ___coverage_array[5095] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arg_count = (int )((unsigned long )*p);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5096] == 0) {
    {
    fprintf(_coverage_fout, "5096\n");
    fflush(_coverage_fout);
    ___coverage_array[5096] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_expect((long )(requested_arg > arg_count), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5097] == 0) {
    {
    fprintf(_coverage_fout, "5097\n");
    fflush(_coverage_fout);
    ___coverage_array[5097] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5092] == 0) {
      {
      fprintf(_coverage_fout, "5092\n");
      fflush(_coverage_fout);
      ___coverage_array[5092] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((zval **)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5093] == 0) {
      {
      fprintf(_coverage_fout, "5093\n");
      fflush(_coverage_fout);
      ___coverage_array[5093] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5098] == 0) {
    {
    fprintf(_coverage_fout, "5098\n");
    fflush(_coverage_fout);
    ___coverage_array[5098] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((((zval **)p - arg_count) + requested_arg) - 1);
}
}
__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 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5099] == 0) {
    {
    fprintf(_coverage_fout, "5099\n");
    fflush(_coverage_fout);
    ___coverage_array[5099] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_ptr_stack_2_pop(stack, & a, & b);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5100] == 0) {
    {
    fprintf(_coverage_fout, "5100\n");
    fflush(_coverage_fout);
    ___coverage_array[5100] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *object = (zval *)a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5101] == 0) {
    {
    fprintf(_coverage_fout, "5101\n");
    fflush(_coverage_fout);
    ___coverage_array[5101] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *fbc = (zend_function *)b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5102] == 0) {
    {
    fprintf(_coverage_fout, "5102\n");
    fflush(_coverage_fout);
    ___coverage_array[5102] = 1;
    }
  }
  fclose(_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 ) 
{ void *a ;
  void *b ;
  void *c ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5103] == 0) {
    {
    fprintf(_coverage_fout, "5103\n");
    fflush(_coverage_fout);
    ___coverage_array[5103] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_ptr_stack_3_pop(stack, & a, & b, & c);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5104] == 0) {
    {
    fprintf(_coverage_fout, "5104\n");
    fflush(_coverage_fout);
    ___coverage_array[5104] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *called_scope = (zend_class_entry *)a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5105] == 0) {
    {
    fprintf(_coverage_fout, "5105\n");
    fflush(_coverage_fout);
    ___coverage_array[5105] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *object = (zval *)b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5106] == 0) {
    {
    fprintf(_coverage_fout, "5106\n");
    fflush(_coverage_fout);
    ___coverage_array[5106] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *fbc = (zend_function *)c;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5107] == 0) {
    {
    fprintf(_coverage_fout, "5107\n");
    fflush(_coverage_fout);
    ___coverage_array[5107] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
extern void execute_new_code(void) ;
extern char const __attribute__((__visibility__("default")))  *get_active_class_name(char const   **space ) ;
extern char const __attribute__((__visibility__("default")))  *get_active_function_name(void) ;
extern char const __attribute__((__visibility__("default")))  *zend_get_executed_filename(void) ;
extern uint __attribute__((__visibility__("default")))  zend_get_executed_lineno(void) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_executing(void) ;
extern void __attribute__((__visibility__("default")))  zend_set_timeout(long seconds ,
                                                                         int reset_signals ) ;
extern void __attribute__((__visibility__("default")))  zend_unset_timeout(void) ;
extern void __attribute__((__visibility__("default")))  zend_timeout(int dummy ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_fetch_class(char const   *class_name ,
                                                                                      uint class_name_len ,
                                                                                      int fetch_type ) ;
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 void zend_verify_abstract_class(zend_class_entry *ce ) ;
extern zval __attribute__((__visibility__("default")))  **zend_get_compiled_variable_value(zend_execute_data const   *execute_data_ptr ,
                                                                                           zend_uint var ) ;
extern int __attribute__((__visibility__("default")))  zend_set_user_opcode_handler(zend_uchar opcode ,
                                                                                    int (*handler)(zend_execute_data *execute_data ) ) ;
extern user_opcode_handler_t __attribute__((__visibility__("default")))  zend_get_user_opcode_handler(zend_uchar opcode ) ;
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 ) ;
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 int __attribute__((__visibility__("default")))  zend_do_fcall(zend_execute_data *execute_data ) ;
extern int zend_next_free_module(void) ;
extern int __attribute__((__visibility__("default")))  zend_get_parameters(int ht ,
                                                                           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"),
__deprecated__))  zend_get_parameters_ex(int param_count  , ...) ;
extern int __attribute__((__visibility__("default")))  _zend_get_parameters_array_ex(int param_count ,
                                                                                     zval ***argument_array ) ;
extern int __attribute__((__visibility__("default")))  zend_copy_parameters_array(int param_count ,
                                                                                  zval *argument_array ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_parameters(int num_args ,
                                                                             char const   *type_spec 
                                                                             , ...) ;
extern int __attribute__((__visibility__("default")))  zend_parse_parameters_ex(int flags ,
                                                                                int num_args ,
                                                                                char const   *type_spec 
                                                                                , ...) ;
extern char __attribute__((__visibility__("default")))  *zend_zval_type_name(zval const   *arg ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_method_parameters(int num_args ,
                                                                                    zval *this_ptr ,
                                                                                    char const   *type_spec 
                                                                                    , ...) ;
extern int __attribute__((__visibility__("default")))  zend_parse_method_parameters_ex(int flags ,
                                                                                       int num_args ,
                                                                                       zval *this_ptr ,
                                                                                       char const   *type_spec 
                                                                                       , ...) ;
extern int __attribute__((__visibility__("default")))  zend_register_functions(zend_class_entry *scope ,
                                                                               zend_function_entry const   *functions ,
                                                                               HashTable *function_table ,
                                                                               int type ) ;
extern void __attribute__((__visibility__("default")))  zend_unregister_functions(zend_function_entry const   *functions ,
                                                                                  int count ,
                                                                                  HashTable *function_table ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_module(zend_module_entry *module_entry ) ;
extern zend_module_entry __attribute__((__visibility__("default")))  *zend_register_internal_module(zend_module_entry *module_entry ) ;
extern zend_module_entry __attribute__((__visibility__("default")))  *zend_register_module_ex(zend_module_entry *module ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_module_ex(zend_module_entry *module ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_modules(void) ;
extern void __attribute__((__visibility__("default")))  zend_collect_module_handlers(void) ;
extern void __attribute__((__visibility__("default")))  zend_destroy_modules(void) ;
extern void __attribute__((__visibility__("default")))  zend_check_magic_method_implementation(zend_class_entry const   *ce ,
                                                                                               zend_function const   *fptr ,
                                                                                               int error_type ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_class(zend_class_entry *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_interface(zend_class_entry *orig_class_entry ) ;
extern void __attribute__((__visibility__("default")))  zend_class_implements(zend_class_entry *class_entry ,
                                                                              int num_interfaces 
                                                                              , ...) ;
extern int __attribute__((__visibility__("default")))  zend_register_class_alias_ex(char const   *name ,
                                                                                    int name_len ,
                                                                                    zend_class_entry *ce ) ;
extern int __attribute__((__visibility__("default")))  zend_disable_function(char *function_name ,
                                                                             uint function_name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_disable_class(char *class_name ,
                                                                          uint class_name_length ) ;
extern void __attribute__((__visibility__("default")))  zend_wrong_param_count(void) ;
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 zend_bool __attribute__((__visibility__("default")))  zend_is_callable(zval *callable ,
                                                                              uint check_flags ,
                                                                              char **callable_name ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_make_callable(zval *callable ,
                                                                                char **callable_name ) ;
extern char const __attribute__((__visibility__("default")))  *zend_get_module_version(char const   *module_name ) ;
extern int __attribute__((__visibility__("default")))  zend_get_module_started(char const   *module_name ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property(zend_class_entry *ce ,
                                                                             char const   *name ,
                                                                             int name_length ,
                                                                             zval *property ,
                                                                             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 const   *doc_comment ,
                                                                                int doc_comment_len ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_null(zend_class_entry *ce ,
                                                                                  char const   *name ,
                                                                                  int name_length ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_bool(zend_class_entry *ce ,
                                                                                  char const   *name ,
                                                                                  int name_length ,
                                                                                  long value ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_long(zend_class_entry *ce ,
                                                                                  char const   *name ,
                                                                                  int name_length ,
                                                                                  long value ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_double(zend_class_entry *ce ,
                                                                                    char const   *name ,
                                                                                    int name_length ,
                                                                                    double value ,
                                                                                    int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_string(zend_class_entry *ce ,
                                                                                    char const   *name ,
                                                                                    int name_length ,
                                                                                    char const   *value ,
                                                                                    int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_stringl(zend_class_entry *ce ,
                                                                                     char const   *name ,
                                                                                     int name_length ,
                                                                                     char const   *value ,
                                                                                     int value_len ,
                                                                                     int access_type ) ;
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_class_constant_null(zend_class_entry *ce ,
                                                                                        char const   *name ,
                                                                                        size_t name_length ) ;
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_bool(zend_class_entry *ce ,
                                                                                        char const   *name ,
                                                                                        size_t name_length ,
                                                                                        zend_bool value ) ;
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_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_string(zend_class_entry *ce ,
                                                                                          char const   *name ,
                                                                                          size_t name_length ,
                                                                                          char const   *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_class_constants(zend_class_entry *class_type ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property(zend_class_entry *scope ,
                                                                             zval *object ,
                                                                             char const   *name ,
                                                                             int name_length ,
                                                                             zval *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_null(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char const   *name ,
                                                                                  int name_length ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_bool(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char const   *name ,
                                                                                  int name_length ,
                                                                                  long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_long(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char const   *name ,
                                                                                  int name_length ,
                                                                                  long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_double(zend_class_entry *scope ,
                                                                                    zval *object ,
                                                                                    char const   *name ,
                                                                                    int name_length ,
                                                                                    double value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_string(zend_class_entry *scope ,
                                                                                    zval *object ,
                                                                                    char const   *name ,
                                                                                    int name_length ,
                                                                                    char const   *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_stringl(zend_class_entry *scope ,
                                                                                     zval *object ,
                                                                                     char const   *name ,
                                                                                     int name_length ,
                                                                                     char const   *value ,
                                                                                     int value_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property(zend_class_entry *scope ,
                                                                                   char const   *name ,
                                                                                   int name_length ,
                                                                                   zval *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_null(zend_class_entry *scope ,
                                                                                        char const   *name ,
                                                                                        int name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_bool(zend_class_entry *scope ,
                                                                                        char const   *name ,
                                                                                        int name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_long(zend_class_entry *scope ,
                                                                                        char const   *name ,
                                                                                        int name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_double(zend_class_entry *scope ,
                                                                                          char const   *name ,
                                                                                          int name_length ,
                                                                                          double value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_string(zend_class_entry *scope ,
                                                                                          char const   *name ,
                                                                                          int name_length ,
                                                                                          char const   *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_stringl(zend_class_entry *scope ,
                                                                                           char const   *name ,
                                                                                           int name_length ,
                                                                                           char const   *value ,
                                                                                           int value_length ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_property(zend_class_entry *scope ,
                                                                            zval *object ,
                                                                            char const   *name ,
                                                                            int name_length ,
                                                                            zend_bool silent ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_static_property(zend_class_entry *scope ,
                                                                                   char const   *name ,
                                                                                   int name_length ,
                                                                                   zend_bool silent ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_get_class_entry(zval const   *zobject ) ;
extern int __attribute__((__visibility__("default")))  zend_get_object_classname(zval const   *object ,
                                                                                 char const   **class_name ,
                                                                                 zend_uint *class_name_len ) ;
extern char __attribute__((__visibility__("default")))  *zend_get_type_by_const(int type ) ;
extern int __attribute__((__visibility__("default")))  _array_init(zval *arg ,
                                                                   uint size ) ;
extern int __attribute__((__visibility__("default")))  _object_init(zval *arg ) ;
extern int __attribute__((__visibility__("default")))  _object_init_ex(zval *arg ,
                                                                       zend_class_entry *ce ) ;
extern int __attribute__((__visibility__("default")))  _object_and_properties_init(zval *arg ,
                                                                                   zend_class_entry *ce ,
                                                                                   HashTable *properties ) ;
extern void __attribute__((__visibility__("default")))  object_properties_init(zend_object *object ,
                                                                               zend_class_entry *class_type ) ;
extern void __attribute__((__visibility__("default")))  zend_merge_properties(zval *obj ,
                                                                              HashTable *properties ,
                                                                              int destroy_ht ) ;
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 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_null_ex(zval *arg ,
                                                                         char const   *key ,
                                                                         uint key_len ) ;
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_resource_ex(zval *arg ,
                                                                             char const   *key ,
                                                                             uint key_len ,
                                                                             int r ) ;
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_string_ex(zval *arg ,
                                                                           char const   *key ,
                                                                           uint key_len ,
                                                                           char *str ,
                                                                           int duplicate ) ;
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_zval_ex(zval *arg ,
                                                                         char const   *key ,
                                                                         uint key_len ,
                                                                         zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_index_long(zval *arg ,
                                                                      ulong idx ,
                                                                      long n ) ;
extern int __attribute__((__visibility__("default")))  add_index_null(zval *arg ,
                                                                      ulong idx ) ;
extern int __attribute__((__visibility__("default")))  add_index_bool(zval *arg ,
                                                                      ulong idx ,
                                                                      int b ) ;
extern int __attribute__((__visibility__("default")))  add_index_resource(zval *arg ,
                                                                          ulong idx ,
                                                                          int r ) ;
extern int __attribute__((__visibility__("default")))  add_index_double(zval *arg ,
                                                                        ulong idx ,
                                                                        double d ) ;
extern int __attribute__((__visibility__("default")))  add_index_string(zval *arg ,
                                                                        ulong idx ,
                                                                        char const   *str ,
                                                                        int duplicate ) ;
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_zval(zval *arg ,
                                                                      ulong index ,
                                                                      zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_long(zval *arg ,
                                                                           long n ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_null(zval *arg ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_bool(zval *arg ,
                                                                           int b ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_resource(zval *arg ,
                                                                               int r ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_double(zval *arg ,
                                                                             double d ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_string(zval *arg ,
                                                                             char const   *str ,
                                                                             int duplicate ) ;
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_zval(zval *arg ,
                                                                           zval *value ) ;
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_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_index_long(zval *arg ,
                                                                          ulong idx ,
                                                                          long l ,
                                                                          void **dest ) ;
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_string(zval *arg ,
                                                                            ulong idx ,
                                                                            char const   *str ,
                                                                            void **dest ,
                                                                            int duplicate ) ;
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_property_long_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ,
                                                                            long l ) ;
extern int __attribute__((__visibility__("default")))  add_property_null_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ) ;
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_resource_ex(zval *arg ,
                                                                                char const   *key ,
                                                                                uint key_len ,
                                                                                long r ) ;
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_string_ex(zval *arg ,
                                                                              char const   *key ,
                                                                              uint key_len ,
                                                                              char const   *str ,
                                                                              int duplicate ) ;
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_zval_ex(zval *arg ,
                                                                            char const   *key ,
                                                                            uint key_len ,
                                                                            zval *value ) ;
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")))  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 zend_fcall_info const __attribute__((__visibility__("default")))  empty_fcall_info ;
extern zend_fcall_info_cache const __attribute__((__visibility__("default")))  empty_fcall_info_cache ;
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 void __attribute__((__visibility__("default")))  zend_fcall_info_args_clear(zend_fcall_info *fci ,
                                                                                   int free_mem ) ;
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_restore(zend_fcall_info *fci ,
                                                                                     int param_count ,
                                                                                     zval ***params ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_args(zend_fcall_info *fci ,
                                                                            zval *args ) ;
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_argv(zend_fcall_info *fci ,
                                                                            int argc ,
                                                                            va_list *argv ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argn(zend_fcall_info *fci ,
                                                                            int argc 
                                                                            , ...) ;
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_call_function(zend_fcall_info *fci ,
                                                                          zend_fcall_info_cache *fci_cache ) ;
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 
                                                                            , ...) ;
extern void __attribute__((__visibility__("default")))  zend_delete_variable(zend_execute_data *ex ,
                                                                             HashTable *ht ,
                                                                             char const   *name ,
                                                                             int name_len ,
                                                                             ulong hash_value ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable(char const   *name ,
                                                                                   int name_len ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable_ex(char const   *name ,
                                                                                      int name_len ,
                                                                                      ulong hash_value ) ;
extern void __attribute__((__visibility__("default")))  zend_reset_all_cv(HashTable *symbol_table ) ;
extern void __attribute__((__visibility__("default")))  zend_rebuild_symbol_table(void) ;
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")))  zif_display_disabled_class(int ht ,
                                                                                   zval *return_value ,
                                                                                   zval **return_value_ptr ,
                                                                                   zval *this_ptr ,
                                                                                   int return_value_used ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_ce_traversable ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_ce_aggregate ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_ce_iterator ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_ce_arrayaccess ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_ce_serializable ;
extern zval __attribute__((__visibility__("default")))  *zend_call_method(zval **object_pp ,
                                                                          zend_class_entry *obj_ce ,
                                                                          zend_function **fn_proxy ,
                                                                          char const   *function_name ,
                                                                          int function_name_len ,
                                                                          zval **retval_ptr_ptr ,
                                                                          int param_count ,
                                                                          zval *arg1 ,
                                                                          zval *arg2 ) ;
extern void __attribute__((__visibility__("default")))  zend_user_it_rewind(zend_object_iterator *_iter ) ;
extern int __attribute__((__visibility__("default")))  zend_user_it_valid(zend_object_iterator *_iter ) ;
extern int __attribute__((__visibility__("default")))  zend_user_it_get_current_key(zend_object_iterator *_iter ,
                                                                                    char **str_key ,
                                                                                    uint *str_key_len ,
                                                                                    ulong *int_key ) ;
extern void __attribute__((__visibility__("default")))  zend_user_it_get_current_data(zend_object_iterator *_iter ,
                                                                                      zval ***data ) ;
extern void __attribute__((__visibility__("default")))  zend_user_it_move_forward(zend_object_iterator *_iter ) ;
extern void __attribute__((__visibility__("default")))  zend_user_it_invalidate_current(zend_object_iterator *_iter ) ;
extern zval __attribute__((__visibility__("default")))  *zend_user_it_new_iterator(zend_class_entry *ce ,
                                                                                   zval *object ) ;
extern zend_object_iterator __attribute__((__visibility__("default")))  *zend_user_it_get_new_iterator(zend_class_entry *ce ,
                                                                                                       zval *object ,
                                                                                                       int by_ref ) ;
extern void __attribute__((__visibility__("default")))  zend_register_interfaces(void) ;
extern int __attribute__((__visibility__("default")))  zend_user_serialize(zval *object ,
                                                                           unsigned char **buffer ,
                                                                           zend_uint *buf_len ,
                                                                           zend_serialize_data *data ) ;
extern int __attribute__((__visibility__("default")))  zend_user_unserialize(zval **object ,
                                                                             zend_class_entry *ce ,
                                                                             unsigned char const   *buf ,
                                                                             zend_uint buf_len ,
                                                                             zend_unserialize_data *data ) ;
extern int __attribute__((__visibility__("default")))  zend_class_serialize_deny(zval *object ,
                                                                                 unsigned char **buffer ,
                                                                                 zend_uint *buf_len ,
                                                                                 zend_serialize_data *data ) ;
extern int __attribute__((__visibility__("default")))  zend_class_unserialize_deny(zval **object ,
                                                                                   zend_class_entry *ce ,
                                                                                   unsigned char const   *buf ,
                                                                                   zend_uint buf_len ,
                                                                                   zend_unserialize_data *data ) ;
extern void zend_register_closure_ce(void) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_ce_closure ;
extern void __attribute__((__visibility__("default")))  zend_create_closure(zval *res ,
                                                                            zend_function *op_array ,
                                                                            zend_class_entry *scope ,
                                                                            zval *this_ptr ) ;
extern zend_function __attribute__((__visibility__("default")))  *zend_get_closure_invoke_method(zval *obj ) ;
extern zend_function const __attribute__((__visibility__("default")))  *zend_get_closure_method_def(zval *obj ) ;
extern zval __attribute__((__visibility__("default")))  *zend_get_closure_this_ptr(zval *obj ) ;
void __attribute__((__visibility__("default")))  rebuild_object_properties(zend_object *zobj ) 
{ HashPosition pos ;
  zend_property_info *prop_info ;
  zend_class_entry *ce ;
  void __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5150] == 0) {
    {
    fprintf(_coverage_fout, "5150\n");
    fflush(_coverage_fout);
    ___coverage_array[5150] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! zobj->properties) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5144] == 0) {
      {
      fprintf(_coverage_fout, "5144\n");
      fflush(_coverage_fout);
      ___coverage_array[5144] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce = zobj->ce;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5145] == 0) {
      {
      fprintf(_coverage_fout, "5145\n");
      fflush(_coverage_fout);
      ___coverage_array[5145] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = _emalloc(sizeof(HashTable ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5146] == 0) {
      {
      fprintf(_coverage_fout, "5146\n");
      fflush(_coverage_fout);
      ___coverage_array[5146] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zobj->properties = (HashTable *)tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5147] == 0) {
      {
      fprintf(_coverage_fout, "5147\n");
      fflush(_coverage_fout);
      ___coverage_array[5147] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_init(zobj->properties, 0U,
                    (ulong (*)(char const   *arKey ,
                               uint nKeyLength ))((void *)0),
                    (void (*)(void * ))(& _zval_ptr_dtor), (unsigned char)0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5148] == 0) {
      {
      fprintf(_coverage_fout, "5148\n");
      fflush(_coverage_fout);
      ___coverage_array[5148] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (ce->default_properties_count) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5140] == 0) {
        {
        fprintf(_coverage_fout, "5140\n");
        fflush(_coverage_fout);
        ___coverage_array[5140] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_hash_internal_pointer_reset_ex(& ce->properties_info, & pos);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5141] == 0) {
        {
        fprintf(_coverage_fout, "5141\n");
        fflush(_coverage_fout);
        ___coverage_array[5141] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5115] == 0) {
          {
          fprintf(_coverage_fout, "5115\n");
          fflush(_coverage_fout);
          ___coverage_array[5115] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = zend_hash_get_current_data_ex(& ce->properties_info,
                                                (void **)(& prop_info), & pos);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5116] == 0) {
          {
          fprintf(_coverage_fout, "5116\n");
          fflush(_coverage_fout);
          ___coverage_array[5116] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___0 == (int __attribute__((__visibility__("default")))  )0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5108] == 0) {
            {
            fprintf(_coverage_fout, "5108\n");
            fflush(_coverage_fout);
            ___coverage_array[5108] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5117] == 0) {
          {
          fprintf(_coverage_fout, "5117\n");
          fflush(_coverage_fout);
          ___coverage_array[5117] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((prop_info->flags & 1U) == 0U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5113] == 0) {
            {
            fprintf(_coverage_fout, "5113\n");
            fflush(_coverage_fout);
            ___coverage_array[5113] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (prop_info->offset >= 0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5111] == 0) {
              {
              fprintf(_coverage_fout, "5111\n");
              fflush(_coverage_fout);
              ___coverage_array[5111] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (*(zobj->properties_table + prop_info->offset)) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5109] == 0) {
                {
                fprintf(_coverage_fout, "5109\n");
                fflush(_coverage_fout);
                ___coverage_array[5109] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _zend_hash_quick_add_or_update(zobj->properties, prop_info->name,
                                             (unsigned int )(prop_info->name_length + 1),
                                             prop_info->h,
                                             (void *)((void **)(zobj->properties_table + prop_info->offset)),
                                             sizeof(zval *),
                                             (void **)(zobj->properties_table + prop_info->offset),
                                             1 << 1);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5110] == 0) {
                {
                fprintf(_coverage_fout, "5110\n");
                fflush(_coverage_fout);
                ___coverage_array[5110] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5112] == 0) {
              {
              fprintf(_coverage_fout, "5112\n");
              fflush(_coverage_fout);
              ___coverage_array[5112] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5114] == 0) {
            {
            fprintf(_coverage_fout, "5114\n");
            fflush(_coverage_fout);
            ___coverage_array[5114] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5118] == 0) {
          {
          fprintf(_coverage_fout, "5118\n");
          fflush(_coverage_fout);
          ___coverage_array[5118] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_hash_move_forward_ex(& ce->properties_info, & pos);
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5142] == 0) {
        {
        fprintf(_coverage_fout, "5142\n");
        fflush(_coverage_fout);
        ___coverage_array[5142] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5136] == 0) {
          {
          fprintf(_coverage_fout, "5136\n");
          fflush(_coverage_fout);
          ___coverage_array[5136] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (ce->parent) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5120] == 0) {
            {
            fprintf(_coverage_fout, "5120\n");
            fflush(_coverage_fout);
            ___coverage_array[5120] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((ce->parent)->default_properties_count) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5119] == 0) {
              {
              fprintf(_coverage_fout, "5119\n");
              fflush(_coverage_fout);
              ___coverage_array[5119] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5137] == 0) {
          {
          fprintf(_coverage_fout, "5137\n");
          fflush(_coverage_fout);
          ___coverage_array[5137] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ce = ce->parent;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5138] == 0) {
          {
          fprintf(_coverage_fout, "5138\n");
          fflush(_coverage_fout);
          ___coverage_array[5138] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_hash_internal_pointer_reset_ex(& ce->properties_info, & pos);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5139] == 0) {
          {
          fprintf(_coverage_fout, "5139\n");
          fflush(_coverage_fout);
          ___coverage_array[5139] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5132] == 0) {
            {
            fprintf(_coverage_fout, "5132\n");
            fflush(_coverage_fout);
            ___coverage_array[5132] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = zend_hash_get_current_data_ex(& ce->properties_info,
                                                  (void **)(& prop_info), & pos);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5133] == 0) {
            {
            fprintf(_coverage_fout, "5133\n");
            fflush(_coverage_fout);
            ___coverage_array[5133] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5121] == 0) {
              {
              fprintf(_coverage_fout, "5121\n");
              fflush(_coverage_fout);
              ___coverage_array[5121] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5134] == 0) {
            {
            fprintf(_coverage_fout, "5134\n");
            fflush(_coverage_fout);
            ___coverage_array[5134] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )prop_info->ce == (unsigned int )ce) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5130] == 0) {
              {
              fprintf(_coverage_fout, "5130\n");
              fflush(_coverage_fout);
              ___coverage_array[5130] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((prop_info->flags & 1U) == 0U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5128] == 0) {
                {
                fprintf(_coverage_fout, "5128\n");
                fflush(_coverage_fout);
                ___coverage_array[5128] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((prop_info->flags & 1024U) != 0U) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5126] == 0) {
                  {
                  fprintf(_coverage_fout, "5126\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5126] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (prop_info->offset >= 0) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5124] == 0) {
                    {
                    fprintf(_coverage_fout, "5124\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5124] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if (*(zobj->properties_table + prop_info->offset)) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5122] == 0) {
                      {
                      fprintf(_coverage_fout, "5122\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5122] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    _zend_hash_quick_add_or_update(zobj->properties,
                                                   prop_info->name,
                                                   (unsigned int )(prop_info->name_length + 1),
                                                   prop_info->h,
                                                   (void *)((void **)(zobj->properties_table + prop_info->offset)),
                                                   sizeof(zval *),
                                                   (void **)(zobj->properties_table + prop_info->offset),
                                                   1 << 1);
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5123] == 0) {
                      {
                      fprintf(_coverage_fout, "5123\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5123] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5125] == 0) {
                    {
                    fprintf(_coverage_fout, "5125\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5125] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5127] == 0) {
                  {
                  fprintf(_coverage_fout, "5127\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5127] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5129] == 0) {
                {
                fprintf(_coverage_fout, "5129\n");
                fflush(_coverage_fout);
                ___coverage_array[5129] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5131] == 0) {
              {
              fprintf(_coverage_fout, "5131\n");
              fflush(_coverage_fout);
              ___coverage_array[5131] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5135] == 0) {
            {
            fprintf(_coverage_fout, "5135\n");
            fflush(_coverage_fout);
            ___coverage_array[5135] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_hash_move_forward_ex(& ce->properties_info, & pos);
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5143] == 0) {
        {
        fprintf(_coverage_fout, "5143\n");
        fflush(_coverage_fout);
        ___coverage_array[5143] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5149] == 0) {
      {
      fprintf(_coverage_fout, "5149\n");
      fflush(_coverage_fout);
      ___coverage_array[5149] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5151] == 0) {
    {
    fprintf(_coverage_fout, "5151\n");
    fflush(_coverage_fout);
    ___coverage_array[5151] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
HashTable __attribute__((__visibility__("default")))  *zend_std_get_properties(zval *object ) 
{ zend_object *zobj ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5154] == 0) {
    {
    fprintf(_coverage_fout, "5154\n");
    fflush(_coverage_fout);
    ___coverage_array[5154] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5155] == 0) {
    {
    fprintf(_coverage_fout, "5155\n");
    fflush(_coverage_fout);
    ___coverage_array[5155] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! zobj->properties) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5152] == 0) {
      {
      fprintf(_coverage_fout, "5152\n");
      fflush(_coverage_fout);
      ___coverage_array[5152] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    rebuild_object_properties(zobj);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5153] == 0) {
      {
      fprintf(_coverage_fout, "5153\n");
      fflush(_coverage_fout);
      ___coverage_array[5153] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5156] == 0) {
    {
    fprintf(_coverage_fout, "5156\n");
    fflush(_coverage_fout);
    ___coverage_array[5156] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((HashTable __attribute__((__visibility__("default")))  *)zobj->properties);
}
}
HashTable __attribute__((__visibility__("default")))  *zend_std_get_debug_info(zval *object ,
                                                                               int *is_temp ) 
{ HashTable __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5157] == 0) {
    {
    fprintf(_coverage_fout, "5157\n");
    fflush(_coverage_fout);
    ___coverage_array[5157] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *is_temp = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5158] == 0) {
    {
    fprintf(_coverage_fout, "5158\n");
    fflush(_coverage_fout);
    ___coverage_array[5158] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_std_get_properties(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5159] == 0) {
    {
    fprintf(_coverage_fout, "5159\n");
    fflush(_coverage_fout);
    ___coverage_array[5159] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
static zval *zend_std_call_getter(zval *object , zval *member ) 
{ zval *retval ;
  zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_bool tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5175] == 0) {
    {
    fprintf(_coverage_fout, "5175\n");
    fflush(_coverage_fout);
    ___coverage_array[5175] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5176] == 0) {
    {
    fprintf(_coverage_fout, "5176\n");
    fflush(_coverage_fout);
    ___coverage_array[5176] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5177] == 0) {
    {
    fprintf(_coverage_fout, "5177\n");
    fflush(_coverage_fout);
    ___coverage_array[5177] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5178] == 0) {
    {
    fprintf(_coverage_fout, "5178\n");
    fflush(_coverage_fout);
    ___coverage_array[5178] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5179] == 0) {
    {
    fprintf(_coverage_fout, "5179\n");
    fflush(_coverage_fout);
    ___coverage_array[5179] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5168] == 0) {
      {
      fprintf(_coverage_fout, "5168\n");
      fflush(_coverage_fout);
      ___coverage_array[5168] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    original_var = member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5169] == 0) {
      {
      fprintf(_coverage_fout, "5169\n");
      fflush(_coverage_fout);
      ___coverage_array[5169] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5160] == 0) {
        {
        fprintf(_coverage_fout, "5160\n");
        fflush(_coverage_fout);
        ___coverage_array[5160] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5161] == 0) {
        {
        fprintf(_coverage_fout, "5161\n");
        fflush(_coverage_fout);
        ___coverage_array[5161] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      member = (zval *)tmp___0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5162] == 0) {
        {
        fprintf(_coverage_fout, "5162\n");
        fflush(_coverage_fout);
        ___coverage_array[5162] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5170] == 0) {
      {
      fprintf(_coverage_fout, "5170\n");
      fflush(_coverage_fout);
      ___coverage_array[5170] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5165] == 0) {
        {
        fprintf(_coverage_fout, "5165\n");
        fflush(_coverage_fout);
        ___coverage_array[5165] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5163] == 0) {
          {
          fprintf(_coverage_fout, "5163\n");
          fflush(_coverage_fout);
          ___coverage_array[5163] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->value = original_var->value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5164] == 0) {
          {
          fprintf(_coverage_fout, "5164\n");
          fflush(_coverage_fout);
          ___coverage_array[5164] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->type = original_var->type;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5166] == 0) {
        {
        fprintf(_coverage_fout, "5166\n");
        fflush(_coverage_fout);
        ___coverage_array[5166] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_set_refcount_p(member, 1U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5167] == 0) {
        {
        fprintf(_coverage_fout, "5167\n");
        fflush(_coverage_fout);
        ___coverage_array[5167] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_unset_isref_p(member);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5171] == 0) {
      {
      fprintf(_coverage_fout, "5171\n");
      fflush(_coverage_fout);
      ___coverage_array[5171] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5172] == 0) {
      {
      fprintf(_coverage_fout, "5172\n");
      fflush(_coverage_fout);
      ___coverage_array[5172] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_addref_p(member);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5180] == 0) {
    {
    fprintf(_coverage_fout, "5180\n");
    fflush(_coverage_fout);
    ___coverage_array[5180] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_call_method(& object, ce, & ce->__get, "__get",
                   (int )(sizeof("__get") - 1U), & retval, 1, member,
                   (zval *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5181] == 0) {
    {
    fprintf(_coverage_fout, "5181\n");
    fflush(_coverage_fout);
    ___coverage_array[5181] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5182] == 0) {
    {
    fprintf(_coverage_fout, "5182\n");
    fflush(_coverage_fout);
    ___coverage_array[5182] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (retval) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5173] == 0) {
      {
      fprintf(_coverage_fout, "5173\n");
      fflush(_coverage_fout);
      ___coverage_array[5173] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_delref_p(retval);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5174] == 0) {
      {
      fprintf(_coverage_fout, "5174\n");
      fflush(_coverage_fout);
      ___coverage_array[5174] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5183] == 0) {
    {
    fprintf(_coverage_fout, "5183\n");
    fflush(_coverage_fout);
    ___coverage_array[5183] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
static int zend_std_call_setter(zval *object , zval *member , zval *value ) 
{ zval *retval ;
  int result ;
  zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_bool tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5204] == 0) {
    {
    fprintf(_coverage_fout, "5204\n");
    fflush(_coverage_fout);
    ___coverage_array[5204] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5205] == 0) {
    {
    fprintf(_coverage_fout, "5205\n");
    fflush(_coverage_fout);
    ___coverage_array[5205] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5206] == 0) {
    {
    fprintf(_coverage_fout, "5206\n");
    fflush(_coverage_fout);
    ___coverage_array[5206] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5207] == 0) {
    {
    fprintf(_coverage_fout, "5207\n");
    fflush(_coverage_fout);
    ___coverage_array[5207] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5208] == 0) {
    {
    fprintf(_coverage_fout, "5208\n");
    fflush(_coverage_fout);
    ___coverage_array[5208] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5192] == 0) {
      {
      fprintf(_coverage_fout, "5192\n");
      fflush(_coverage_fout);
      ___coverage_array[5192] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    original_var = member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5193] == 0) {
      {
      fprintf(_coverage_fout, "5193\n");
      fflush(_coverage_fout);
      ___coverage_array[5193] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5184] == 0) {
        {
        fprintf(_coverage_fout, "5184\n");
        fflush(_coverage_fout);
        ___coverage_array[5184] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5185] == 0) {
        {
        fprintf(_coverage_fout, "5185\n");
        fflush(_coverage_fout);
        ___coverage_array[5185] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      member = (zval *)tmp___0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5186] == 0) {
        {
        fprintf(_coverage_fout, "5186\n");
        fflush(_coverage_fout);
        ___coverage_array[5186] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5194] == 0) {
      {
      fprintf(_coverage_fout, "5194\n");
      fflush(_coverage_fout);
      ___coverage_array[5194] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5189] == 0) {
        {
        fprintf(_coverage_fout, "5189\n");
        fflush(_coverage_fout);
        ___coverage_array[5189] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5187] == 0) {
          {
          fprintf(_coverage_fout, "5187\n");
          fflush(_coverage_fout);
          ___coverage_array[5187] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->value = original_var->value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5188] == 0) {
          {
          fprintf(_coverage_fout, "5188\n");
          fflush(_coverage_fout);
          ___coverage_array[5188] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->type = original_var->type;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5190] == 0) {
        {
        fprintf(_coverage_fout, "5190\n");
        fflush(_coverage_fout);
        ___coverage_array[5190] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_set_refcount_p(member, 1U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5191] == 0) {
        {
        fprintf(_coverage_fout, "5191\n");
        fflush(_coverage_fout);
        ___coverage_array[5191] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_unset_isref_p(member);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5195] == 0) {
      {
      fprintf(_coverage_fout, "5195\n");
      fflush(_coverage_fout);
      ___coverage_array[5195] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5196] == 0) {
      {
      fprintf(_coverage_fout, "5196\n");
      fflush(_coverage_fout);
      ___coverage_array[5196] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_addref_p(member);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5209] == 0) {
    {
    fprintf(_coverage_fout, "5209\n");
    fflush(_coverage_fout);
    ___coverage_array[5209] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_addref_p(value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5210] == 0) {
    {
    fprintf(_coverage_fout, "5210\n");
    fflush(_coverage_fout);
    ___coverage_array[5210] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_call_method(& object, ce, & ce->__set, "__set",
                   (int )(sizeof("__set") - 1U), & retval, 2, member, value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5211] == 0) {
    {
    fprintf(_coverage_fout, "5211\n");
    fflush(_coverage_fout);
    ___coverage_array[5211] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5212] == 0) {
    {
    fprintf(_coverage_fout, "5212\n");
    fflush(_coverage_fout);
    ___coverage_array[5212] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5213] == 0) {
    {
    fprintf(_coverage_fout, "5213\n");
    fflush(_coverage_fout);
    ___coverage_array[5213] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (retval) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5199] == 0) {
      {
      fprintf(_coverage_fout, "5199\n");
      fflush(_coverage_fout);
      ___coverage_array[5199] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = i_zend_is_true(retval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5200] == 0) {
      {
      fprintf(_coverage_fout, "5200\n");
      fflush(_coverage_fout);
      ___coverage_array[5200] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5197] == 0) {
        {
        fprintf(_coverage_fout, "5197\n");
        fflush(_coverage_fout);
        ___coverage_array[5197] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = 0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5198] == 0) {
        {
        fprintf(_coverage_fout, "5198\n");
        fflush(_coverage_fout);
        ___coverage_array[5198] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = -1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5201] == 0) {
      {
      fprintf(_coverage_fout, "5201\n");
      fflush(_coverage_fout);
      ___coverage_array[5201] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& retval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5202] == 0) {
      {
      fprintf(_coverage_fout, "5202\n");
      fflush(_coverage_fout);
      ___coverage_array[5202] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (result);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5203] == 0) {
      {
      fprintf(_coverage_fout, "5203\n");
      fflush(_coverage_fout);
      ___coverage_array[5203] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (-1);
  }
}
}
static void zend_std_call_unsetter(zval *object , zval *member ) 
{ zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_bool tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5227] == 0) {
    {
    fprintf(_coverage_fout, "5227\n");
    fflush(_coverage_fout);
    ___coverage_array[5227] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5228] == 0) {
    {
    fprintf(_coverage_fout, "5228\n");
    fflush(_coverage_fout);
    ___coverage_array[5228] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5229] == 0) {
    {
    fprintf(_coverage_fout, "5229\n");
    fflush(_coverage_fout);
    ___coverage_array[5229] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5230] == 0) {
    {
    fprintf(_coverage_fout, "5230\n");
    fflush(_coverage_fout);
    ___coverage_array[5230] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5222] == 0) {
      {
      fprintf(_coverage_fout, "5222\n");
      fflush(_coverage_fout);
      ___coverage_array[5222] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    original_var = member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5223] == 0) {
      {
      fprintf(_coverage_fout, "5223\n");
      fflush(_coverage_fout);
      ___coverage_array[5223] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5214] == 0) {
        {
        fprintf(_coverage_fout, "5214\n");
        fflush(_coverage_fout);
        ___coverage_array[5214] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5215] == 0) {
        {
        fprintf(_coverage_fout, "5215\n");
        fflush(_coverage_fout);
        ___coverage_array[5215] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      member = (zval *)tmp___0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5216] == 0) {
        {
        fprintf(_coverage_fout, "5216\n");
        fflush(_coverage_fout);
        ___coverage_array[5216] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5224] == 0) {
      {
      fprintf(_coverage_fout, "5224\n");
      fflush(_coverage_fout);
      ___coverage_array[5224] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5219] == 0) {
        {
        fprintf(_coverage_fout, "5219\n");
        fflush(_coverage_fout);
        ___coverage_array[5219] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5217] == 0) {
          {
          fprintf(_coverage_fout, "5217\n");
          fflush(_coverage_fout);
          ___coverage_array[5217] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->value = original_var->value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5218] == 0) {
          {
          fprintf(_coverage_fout, "5218\n");
          fflush(_coverage_fout);
          ___coverage_array[5218] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->type = original_var->type;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5220] == 0) {
        {
        fprintf(_coverage_fout, "5220\n");
        fflush(_coverage_fout);
        ___coverage_array[5220] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_set_refcount_p(member, 1U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5221] == 0) {
        {
        fprintf(_coverage_fout, "5221\n");
        fflush(_coverage_fout);
        ___coverage_array[5221] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_unset_isref_p(member);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5225] == 0) {
      {
      fprintf(_coverage_fout, "5225\n");
      fflush(_coverage_fout);
      ___coverage_array[5225] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5226] == 0) {
      {
      fprintf(_coverage_fout, "5226\n");
      fflush(_coverage_fout);
      ___coverage_array[5226] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_addref_p(member);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5231] == 0) {
    {
    fprintf(_coverage_fout, "5231\n");
    fflush(_coverage_fout);
    ___coverage_array[5231] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_call_method(& object, ce, & ce->__unset, "__unset",
                   (int )(sizeof("__unset") - 1U), (zval **)((void *)0), 1,
                   member, (zval *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5232] == 0) {
    {
    fprintf(_coverage_fout, "5232\n");
    fflush(_coverage_fout);
    ___coverage_array[5232] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5233] == 0) {
    {
    fprintf(_coverage_fout, "5233\n");
    fflush(_coverage_fout);
    ___coverage_array[5233] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static zval *zend_std_call_issetter(zval *object , zval *member ) 
{ zval *retval ;
  zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_bool tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5247] == 0) {
    {
    fprintf(_coverage_fout, "5247\n");
    fflush(_coverage_fout);
    ___coverage_array[5247] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5248] == 0) {
    {
    fprintf(_coverage_fout, "5248\n");
    fflush(_coverage_fout);
    ___coverage_array[5248] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5249] == 0) {
    {
    fprintf(_coverage_fout, "5249\n");
    fflush(_coverage_fout);
    ___coverage_array[5249] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5250] == 0) {
    {
    fprintf(_coverage_fout, "5250\n");
    fflush(_coverage_fout);
    ___coverage_array[5250] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5251] == 0) {
    {
    fprintf(_coverage_fout, "5251\n");
    fflush(_coverage_fout);
    ___coverage_array[5251] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5242] == 0) {
      {
      fprintf(_coverage_fout, "5242\n");
      fflush(_coverage_fout);
      ___coverage_array[5242] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    original_var = member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5243] == 0) {
      {
      fprintf(_coverage_fout, "5243\n");
      fflush(_coverage_fout);
      ___coverage_array[5243] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5234] == 0) {
        {
        fprintf(_coverage_fout, "5234\n");
        fflush(_coverage_fout);
        ___coverage_array[5234] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5235] == 0) {
        {
        fprintf(_coverage_fout, "5235\n");
        fflush(_coverage_fout);
        ___coverage_array[5235] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      member = (zval *)tmp___0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5236] == 0) {
        {
        fprintf(_coverage_fout, "5236\n");
        fflush(_coverage_fout);
        ___coverage_array[5236] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5244] == 0) {
      {
      fprintf(_coverage_fout, "5244\n");
      fflush(_coverage_fout);
      ___coverage_array[5244] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5239] == 0) {
        {
        fprintf(_coverage_fout, "5239\n");
        fflush(_coverage_fout);
        ___coverage_array[5239] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5237] == 0) {
          {
          fprintf(_coverage_fout, "5237\n");
          fflush(_coverage_fout);
          ___coverage_array[5237] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->value = original_var->value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5238] == 0) {
          {
          fprintf(_coverage_fout, "5238\n");
          fflush(_coverage_fout);
          ___coverage_array[5238] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        member->type = original_var->type;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5240] == 0) {
        {
        fprintf(_coverage_fout, "5240\n");
        fflush(_coverage_fout);
        ___coverage_array[5240] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_set_refcount_p(member, 1U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5241] == 0) {
        {
        fprintf(_coverage_fout, "5241\n");
        fflush(_coverage_fout);
        ___coverage_array[5241] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_unset_isref_p(member);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5245] == 0) {
      {
      fprintf(_coverage_fout, "5245\n");
      fflush(_coverage_fout);
      ___coverage_array[5245] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5246] == 0) {
      {
      fprintf(_coverage_fout, "5246\n");
      fflush(_coverage_fout);
      ___coverage_array[5246] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_addref_p(member);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5252] == 0) {
    {
    fprintf(_coverage_fout, "5252\n");
    fflush(_coverage_fout);
    ___coverage_array[5252] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_call_method(& object, ce, & ce->__isset, "__isset",
                   (int )(sizeof("__isset") - 1U), & retval, 1, member,
                   (zval *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5253] == 0) {
    {
    fprintf(_coverage_fout, "5253\n");
    fflush(_coverage_fout);
    ___coverage_array[5253] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& member);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5254] == 0) {
    {
    fprintf(_coverage_fout, "5254\n");
    fflush(_coverage_fout);
    ___coverage_array[5254] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
__inline static int ( __attribute__((__always_inline__)) zend_verify_property_access)(zend_property_info *property_info ,
                                                                                      zend_class_entry *ce ) 
{ int __attribute__((__visibility__("default")))  tmp ;

  {
  switch ((int )(property_info->flags & 1792U)) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5260] == 0) {
    {
    fprintf(_coverage_fout, "5260\n");
    fflush(_coverage_fout);
    ___coverage_array[5260] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 0x100: 
  return (1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5261] == 0) {
    {
    fprintf(_coverage_fout, "5261\n");
    fflush(_coverage_fout);
    ___coverage_array[5261] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 0x200: 
  tmp = zend_check_protected(property_info->ce, executor_globals.scope);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5262] == 0) {
    {
    fprintf(_coverage_fout, "5262\n");
    fflush(_coverage_fout);
    ___coverage_array[5262] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5263] == 0) {
    {
    fprintf(_coverage_fout, "5263\n");
    fflush(_coverage_fout);
    ___coverage_array[5263] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 0x400: 
  if ((unsigned int )ce == (unsigned int )executor_globals.scope) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5259] == 0) {
      {
      fprintf(_coverage_fout, "5259\n");
      fflush(_coverage_fout);
      ___coverage_array[5259] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )property_info->ce == (unsigned int )executor_globals.scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5257] == 0) {
        {
        fprintf(_coverage_fout, "5257\n");
        fflush(_coverage_fout);
        ___coverage_array[5257] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L: /* CIL Label */ 
      if (executor_globals.scope) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5255] == 0) {
          {
          fprintf(_coverage_fout, "5255\n");
          fflush(_coverage_fout);
          ___coverage_array[5255] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (1);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5256] == 0) {
          {
          fprintf(_coverage_fout, "5256\n");
          fflush(_coverage_fout);
          ___coverage_array[5256] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (0);
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5258] == 0) {
        {
        fprintf(_coverage_fout, "5258\n");
        fflush(_coverage_fout);
        ___coverage_array[5258] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    }
  }
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5264] == 0) {
    {
    fprintf(_coverage_fout, "5264\n");
    fflush(_coverage_fout);
    ___coverage_array[5264] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) is_derived_class)(zend_class_entry *child_class ,
                                                                                 zend_class_entry *parent_class ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5271] == 0) {
    {
    fprintf(_coverage_fout, "5271\n");
    fflush(_coverage_fout);
    ___coverage_array[5271] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  child_class = child_class->parent;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5272] == 0) {
    {
    fprintf(_coverage_fout, "5272\n");
    fflush(_coverage_fout);
    ___coverage_array[5272] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5268] == 0) {
      {
      fprintf(_coverage_fout, "5268\n");
      fflush(_coverage_fout);
      ___coverage_array[5268] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (child_class) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5265] == 0) {
        {
        fprintf(_coverage_fout, "5265\n");
        fflush(_coverage_fout);
        ___coverage_array[5265] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5269] == 0) {
      {
      fprintf(_coverage_fout, "5269\n");
      fflush(_coverage_fout);
      ___coverage_array[5269] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )child_class == (unsigned int )parent_class) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5266] == 0) {
        {
        fprintf(_coverage_fout, "5266\n");
        fflush(_coverage_fout);
        ___coverage_array[5266] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((unsigned char)1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5267] == 0) {
        {
        fprintf(_coverage_fout, "5267\n");
        fflush(_coverage_fout);
        ___coverage_array[5267] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5270] == 0) {
      {
      fprintf(_coverage_fout, "5270\n");
      fflush(_coverage_fout);
      ___coverage_array[5270] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    child_class = child_class->parent;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5273] == 0) {
    {
    fprintf(_coverage_fout, "5273\n");
    fflush(_coverage_fout);
    ___coverage_array[5273] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((unsigned char)0);
}
}
__inline static struct _zend_property_info *( __attribute__((__always_inline__)) zend_get_property_info_quick)(zend_class_entry *ce ,
                                                                                                               zval *member ,
                                                                                                               int silent ,
                                                                                                               zend_literal const   *key ) 
{ zend_property_info *property_info ;
  zend_property_info *scope_property_info ;
  zend_bool denied_access ;
  ulong h ;
  long tmp ;
  ulong __attribute__((__visibility__("default")))  tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  int tmp___4 ;
  long tmp___5 ;
  long tmp___6 ;
  int __attribute__((__visibility__("default")))  tmp___7 ;
  char *tmp___8 ;
  long tmp___9 ;
  zend_bool tmp___10 ;
  int __attribute__((__visibility__("default")))  tmp___11 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5348] == 0) {
    {
    fprintf(_coverage_fout, "5348\n");
    fflush(_coverage_fout);
    ___coverage_array[5348] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  denied_access = (zend_bool )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5349] == 0) {
    {
    fprintf(_coverage_fout, "5349\n");
    fflush(_coverage_fout);
    ___coverage_array[5349] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (key) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5278] == 0) {
      {
      fprintf(_coverage_fout, "5278\n");
      fflush(_coverage_fout);
      ___coverage_array[5278] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )*((executor_globals.active_op_array)->run_time_cache + key->cache_slot) == (unsigned int )ce) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5274] == 0) {
        {
        fprintf(_coverage_fout, "5274\n");
        fflush(_coverage_fout);
        ___coverage_array[5274] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      property_info = (zend_property_info *)*((executor_globals.active_op_array)->run_time_cache + (key->cache_slot + 1U));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5275] == 0) {
        {
        fprintf(_coverage_fout, "5275\n");
        fflush(_coverage_fout);
        ___coverage_array[5275] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      property_info = (zend_property_info *)((void *)0);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5279] == 0) {
      {
      fprintf(_coverage_fout, "5279\n");
      fflush(_coverage_fout);
      ___coverage_array[5279] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )property_info != (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5276] == 0) {
        {
        fprintf(_coverage_fout, "5276\n");
        fflush(_coverage_fout);
        ___coverage_array[5276] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (property_info);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5277] == 0) {
        {
        fprintf(_coverage_fout, "5277\n");
        fflush(_coverage_fout);
        ___coverage_array[5277] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5280] == 0) {
      {
      fprintf(_coverage_fout, "5280\n");
      fflush(_coverage_fout);
      ___coverage_array[5280] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5350] == 0) {
    {
    fprintf(_coverage_fout, "5350\n");
    fflush(_coverage_fout);
    ___coverage_array[5350] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_expect((long )((int )*(member->value.str.val + 0) == 0), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5351] == 0) {
    {
    fprintf(_coverage_fout, "5351\n");
    fflush(_coverage_fout);
    ___coverage_array[5351] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5285] == 0) {
      {
      fprintf(_coverage_fout, "5285\n");
      fflush(_coverage_fout);
      ___coverage_array[5285] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! silent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5283] == 0) {
        {
        fprintf(_coverage_fout, "5283\n");
        fflush(_coverage_fout);
        ___coverage_array[5283] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (member->value.str.len == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5281] == 0) {
          {
          fprintf(_coverage_fout, "5281\n");
          fflush(_coverage_fout);
          ___coverage_array[5281] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_error_noreturn(1, "Cannot access empty property");
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5282] == 0) {
          {
          fprintf(_coverage_fout, "5282\n");
          fflush(_coverage_fout);
          ___coverage_array[5282] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_error_noreturn(1, "Cannot access property started with \'\\0\'");
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5284] == 0) {
        {
        fprintf(_coverage_fout, "5284\n");
        fflush(_coverage_fout);
        ___coverage_array[5284] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5286] == 0) {
      {
      fprintf(_coverage_fout, "5286\n");
      fflush(_coverage_fout);
      ___coverage_array[5286] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((struct _zend_property_info *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5287] == 0) {
      {
      fprintf(_coverage_fout, "5287\n");
      fflush(_coverage_fout);
      ___coverage_array[5287] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5352] == 0) {
    {
    fprintf(_coverage_fout, "5352\n");
    fflush(_coverage_fout);
    ___coverage_array[5352] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = (zend_property_info *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5353] == 0) {
    {
    fprintf(_coverage_fout, "5353\n");
    fflush(_coverage_fout);
    ___coverage_array[5353] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (key) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5288] == 0) {
      {
      fprintf(_coverage_fout, "5288\n");
      fflush(_coverage_fout);
      ___coverage_array[5288] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    h = (unsigned long )key->hash_value;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5289] == 0) {
      {
      fprintf(_coverage_fout, "5289\n");
      fflush(_coverage_fout);
      ___coverage_array[5289] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = zend_get_hash_value((char const   *)member->value.str.val,
                                  (unsigned int )(member->value.str.len + 1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5290] == 0) {
      {
      fprintf(_coverage_fout, "5290\n");
      fflush(_coverage_fout);
      ___coverage_array[5290] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    h = (unsigned long )tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5354] == 0) {
    {
    fprintf(_coverage_fout, "5354\n");
    fflush(_coverage_fout);
    ___coverage_array[5354] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___7 = zend_hash_quick_find((HashTable const   *)(& ce->properties_info),
                                 (char const   *)member->value.str.val,
                                 (unsigned int )(member->value.str.len + 1), h,
                                 (void **)(& property_info));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5355] == 0) {
    {
    fprintf(_coverage_fout, "5355\n");
    fflush(_coverage_fout);
    ___coverage_array[5355] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___7 == (int __attribute__((__visibility__("default")))  )0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5313] == 0) {
      {
      fprintf(_coverage_fout, "5313\n");
      fflush(_coverage_fout);
      ___coverage_array[5313] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = __builtin_expect((long )((property_info->flags & 131072U) != 0U),
                               0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5314] == 0) {
      {
      fprintf(_coverage_fout, "5314\n");
      fflush(_coverage_fout);
      ___coverage_array[5314] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5291] == 0) {
        {
        fprintf(_coverage_fout, "5291\n");
        fflush(_coverage_fout);
        ___coverage_array[5291] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      property_info = (zend_property_info *)((void *)0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5310] == 0) {
        {
        fprintf(_coverage_fout, "5310\n");
        fflush(_coverage_fout);
        ___coverage_array[5310] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = zend_verify_property_access(property_info, ce);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5311] == 0) {
        {
        fprintf(_coverage_fout, "5311\n");
        fflush(_coverage_fout);
        ___coverage_array[5311] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = __builtin_expect((long )(tmp___4 != 0), 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5312] == 0) {
        {
        fprintf(_coverage_fout, "5312\n");
        fflush(_coverage_fout);
        ___coverage_array[5312] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___5) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5307] == 0) {
          {
          fprintf(_coverage_fout, "5307\n");
          fflush(_coverage_fout);
          ___coverage_array[5307] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___2 = __builtin_expect((long )((property_info->flags & 2048U) != 0U),
                                   1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5308] == 0) {
          {
          fprintf(_coverage_fout, "5308\n");
          fflush(_coverage_fout);
          ___coverage_array[5308] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5293] == 0) {
            {
            fprintf(_coverage_fout, "5293\n");
            fflush(_coverage_fout);
            ___coverage_array[5293] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___3 = __builtin_expect((long )(! (property_info->flags & 1024U)),
                                     1L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5294] == 0) {
            {
            fprintf(_coverage_fout, "5294\n");
            fflush(_coverage_fout);
            ___coverage_array[5294] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5292] == 0) {
              {
              fprintf(_coverage_fout, "5292\n");
              fflush(_coverage_fout);
              ___coverage_array[5292] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            goto _L;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5303] == 0) {
            {
            fprintf(_coverage_fout, "5303\n");
            fflush(_coverage_fout);
            ___coverage_array[5303] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L: /* CIL Label */ 
          tmp___1 = __builtin_expect((long )((property_info->flags & 1U) != 0U),
                                     0L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5304] == 0) {
            {
            fprintf(_coverage_fout, "5304\n");
            fflush(_coverage_fout);
            ___coverage_array[5304] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5297] == 0) {
              {
              fprintf(_coverage_fout, "5297\n");
              fflush(_coverage_fout);
              ___coverage_array[5297] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (! silent) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5295] == 0) {
                {
                fprintf(_coverage_fout, "5295\n");
                fflush(_coverage_fout);
                ___coverage_array[5295] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zend_error(1 << 11L,
                         "Accessing static property %s::$%s as non static",
                         ce->name, member->value.str.val);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5296] == 0) {
                {
                fprintf(_coverage_fout, "5296\n");
                fflush(_coverage_fout);
                ___coverage_array[5296] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5298] == 0) {
              {
              fprintf(_coverage_fout, "5298\n");
              fflush(_coverage_fout);
              ___coverage_array[5298] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5305] == 0) {
            {
            fprintf(_coverage_fout, "5305\n");
            fflush(_coverage_fout);
            ___coverage_array[5305] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (key) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5301] == 0) {
              {
              fprintf(_coverage_fout, "5301\n");
              fflush(_coverage_fout);
              ___coverage_array[5301] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            while (1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5299] == 0) {
                {
                fprintf(_coverage_fout, "5299\n");
                fflush(_coverage_fout);
                ___coverage_array[5299] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              *((executor_globals.active_op_array)->run_time_cache + key->cache_slot) = (void *)ce;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5300] == 0) {
                {
                fprintf(_coverage_fout, "5300\n");
                fflush(_coverage_fout);
                ___coverage_array[5300] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              *((executor_globals.active_op_array)->run_time_cache + (key->cache_slot + 1U)) = (void *)property_info;
              break;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5302] == 0) {
              {
              fprintf(_coverage_fout, "5302\n");
              fflush(_coverage_fout);
              ___coverage_array[5302] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5306] == 0) {
            {
            fprintf(_coverage_fout, "5306\n");
            fflush(_coverage_fout);
            ___coverage_array[5306] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (property_info);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5309] == 0) {
          {
          fprintf(_coverage_fout, "5309\n");
          fflush(_coverage_fout);
          ___coverage_array[5309] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        denied_access = (unsigned char)1;
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5315] == 0) {
      {
      fprintf(_coverage_fout, "5315\n");
      fflush(_coverage_fout);
      ___coverage_array[5315] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5356] == 0) {
    {
    fprintf(_coverage_fout, "5356\n");
    fflush(_coverage_fout);
    ___coverage_array[5356] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )executor_globals.scope != (unsigned int )ce) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5327] == 0) {
      {
      fprintf(_coverage_fout, "5327\n");
      fflush(_coverage_fout);
      ___coverage_array[5327] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (executor_globals.scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5325] == 0) {
        {
        fprintf(_coverage_fout, "5325\n");
        fflush(_coverage_fout);
        ___coverage_array[5325] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___10 = is_derived_class(ce, executor_globals.scope);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5326] == 0) {
        {
        fprintf(_coverage_fout, "5326\n");
        fflush(_coverage_fout);
        ___coverage_array[5326] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___10) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5323] == 0) {
          {
          fprintf(_coverage_fout, "5323\n");
          fflush(_coverage_fout);
          ___coverage_array[5323] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___11 = zend_hash_quick_find((HashTable const   *)(& (executor_globals.scope)->properties_info),
                                        (char const   *)member->value.str.val,
                                        (unsigned int )(member->value.str.len + 1),
                                        h, (void **)(& scope_property_info));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5324] == 0) {
          {
          fprintf(_coverage_fout, "5324\n");
          fflush(_coverage_fout);
          ___coverage_array[5324] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___11 == (int __attribute__((__visibility__("default")))  )0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5322] == 0) {
            {
            fprintf(_coverage_fout, "5322\n");
            fflush(_coverage_fout);
            ___coverage_array[5322] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (scope_property_info->flags & 1024U) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5320] == 0) {
              {
              fprintf(_coverage_fout, "5320\n");
              fflush(_coverage_fout);
              ___coverage_array[5320] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (key) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5318] == 0) {
                {
                fprintf(_coverage_fout, "5318\n");
                fflush(_coverage_fout);
                ___coverage_array[5318] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              while (1) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5316] == 0) {
                  {
                  fprintf(_coverage_fout, "5316\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5316] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                *((executor_globals.active_op_array)->run_time_cache + key->cache_slot) = (void *)ce;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5317] == 0) {
                  {
                  fprintf(_coverage_fout, "5317\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5317] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                *((executor_globals.active_op_array)->run_time_cache + (key->cache_slot + 1U)) = (void *)scope_property_info;
                break;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5319] == 0) {
                {
                fprintf(_coverage_fout, "5319\n");
                fflush(_coverage_fout);
                ___coverage_array[5319] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5321] == 0) {
              {
              fprintf(_coverage_fout, "5321\n");
              fflush(_coverage_fout);
              ___coverage_array[5321] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return (scope_property_info);
          } else {
            goto _L___3;
          }
        } else {
          goto _L___3;
        }
      } else {
        goto _L___3;
      }
    } else {
      goto _L___3;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5347] == 0) {
      {
      fprintf(_coverage_fout, "5347\n");
      fflush(_coverage_fout);
      ___coverage_array[5347] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L___3: /* CIL Label */ 
    _L___2: /* CIL Label */ 
    _L___1: /* CIL Label */ 
    _L___0: /* CIL Label */ 
    if (property_info) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5338] == 0) {
        {
        fprintf(_coverage_fout, "5338\n");
        fflush(_coverage_fout);
        ___coverage_array[5338] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___9 = __builtin_expect((long )((int )denied_access != 0), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5339] == 0) {
        {
        fprintf(_coverage_fout, "5339\n");
        fflush(_coverage_fout);
        ___coverage_array[5339] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___9) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5331] == 0) {
          {
          fprintf(_coverage_fout, "5331\n");
          fflush(_coverage_fout);
          ___coverage_array[5331] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! silent) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5328] == 0) {
            {
            fprintf(_coverage_fout, "5328\n");
            fflush(_coverage_fout);
            ___coverage_array[5328] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = zend_visibility_string(property_info->flags);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5329] == 0) {
            {
            fprintf(_coverage_fout, "5329\n");
            fflush(_coverage_fout);
            ___coverage_array[5329] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1, "Cannot access %s property %s::$%s", tmp___8,
                              ce->name, member->value.str.val);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5330] == 0) {
            {
            fprintf(_coverage_fout, "5330\n");
            fflush(_coverage_fout);
            ___coverage_array[5330] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5332] == 0) {
          {
          fprintf(_coverage_fout, "5332\n");
          fflush(_coverage_fout);
          ___coverage_array[5332] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((struct _zend_property_info *)((void *)0));
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5337] == 0) {
          {
          fprintf(_coverage_fout, "5337\n");
          fflush(_coverage_fout);
          ___coverage_array[5337] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (key) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5335] == 0) {
            {
            fprintf(_coverage_fout, "5335\n");
            fflush(_coverage_fout);
            ___coverage_array[5335] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5333] == 0) {
              {
              fprintf(_coverage_fout, "5333\n");
              fflush(_coverage_fout);
              ___coverage_array[5333] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *((executor_globals.active_op_array)->run_time_cache + key->cache_slot) = (void *)ce;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5334] == 0) {
              {
              fprintf(_coverage_fout, "5334\n");
              fflush(_coverage_fout);
              ___coverage_array[5334] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *((executor_globals.active_op_array)->run_time_cache + (key->cache_slot + 1U)) = (void *)property_info;
            break;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5336] == 0) {
            {
            fprintf(_coverage_fout, "5336\n");
            fflush(_coverage_fout);
            ___coverage_array[5336] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5340] == 0) {
        {
        fprintf(_coverage_fout, "5340\n");
        fflush(_coverage_fout);
        ___coverage_array[5340] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      executor_globals.std_property_info.flags = 256U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5341] == 0) {
        {
        fprintf(_coverage_fout, "5341\n");
        fflush(_coverage_fout);
        ___coverage_array[5341] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      executor_globals.std_property_info.name = (char const   *)member->value.str.val;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5342] == 0) {
        {
        fprintf(_coverage_fout, "5342\n");
        fflush(_coverage_fout);
        ___coverage_array[5342] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      executor_globals.std_property_info.name_length = member->value.str.len;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5343] == 0) {
        {
        fprintf(_coverage_fout, "5343\n");
        fflush(_coverage_fout);
        ___coverage_array[5343] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      executor_globals.std_property_info.h = h;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5344] == 0) {
        {
        fprintf(_coverage_fout, "5344\n");
        fflush(_coverage_fout);
        ___coverage_array[5344] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      executor_globals.std_property_info.ce = ce;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5345] == 0) {
        {
        fprintf(_coverage_fout, "5345\n");
        fflush(_coverage_fout);
        ___coverage_array[5345] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      executor_globals.std_property_info.offset = -1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5346] == 0) {
        {
        fprintf(_coverage_fout, "5346\n");
        fflush(_coverage_fout);
        ___coverage_array[5346] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      property_info = & executor_globals.std_property_info;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5357] == 0) {
    {
    fprintf(_coverage_fout, "5357\n");
    fflush(_coverage_fout);
    ___coverage_array[5357] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (property_info);
}
}
struct _zend_property_info  __attribute__((__visibility__("default"))) *zend_get_property_info(zend_class_entry *ce ,
                                                                                               zval *member ,
                                                                                               int silent ) 
{ struct _zend_property_info *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5358] == 0) {
    {
    fprintf(_coverage_fout, "5358\n");
    fflush(_coverage_fout);
    ___coverage_array[5358] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_property_info_quick(ce, member, silent,
                                     (zend_literal const   *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5359] == 0) {
    {
    fprintf(_coverage_fout, "5359\n");
    fflush(_coverage_fout);
    ___coverage_array[5359] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((struct _zend_property_info  __attribute__((__visibility__("default"))) *)tmp);
}
}
int __attribute__((__visibility__("default")))  zend_check_property_access(zend_object *zobj ,
                                                                           char const   *prop_info_name ,
                                                                           int prop_info_name_len ) 
{ zend_property_info *property_info ;
  char const   *class_name ;
  char const   *prop_name ;
  zval member ;
  char const   *__s ;
  zval *__z ;
  size_t tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___4 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  int tmp___10 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5396] == 0) {
    {
    fprintf(_coverage_fout, "5396\n");
    fflush(_coverage_fout);
    ___coverage_array[5396] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_unmangle_property_name(prop_info_name, prop_info_name_len, & class_name,
                              & prop_name);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5397] == 0) {
    {
    fprintf(_coverage_fout, "5397\n");
    fflush(_coverage_fout);
    ___coverage_array[5397] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5360] == 0) {
      {
      fprintf(_coverage_fout, "5360\n");
      fflush(_coverage_fout);
      ___coverage_array[5360] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = prop_name;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5361] == 0) {
      {
      fprintf(_coverage_fout, "5361\n");
      fflush(_coverage_fout);
      ___coverage_array[5361] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z = & member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5362] == 0) {
      {
      fprintf(_coverage_fout, "5362\n");
      fflush(_coverage_fout);
      ___coverage_array[5362] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5363] == 0) {
      {
      fprintf(_coverage_fout, "5363\n");
      fflush(_coverage_fout);
      ___coverage_array[5363] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.len = (int )tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5364] == 0) {
      {
      fprintf(_coverage_fout, "5364\n");
      fflush(_coverage_fout);
      ___coverage_array[5364] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5365] == 0) {
      {
      fprintf(_coverage_fout, "5365\n");
      fflush(_coverage_fout);
      ___coverage_array[5365] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5398] == 0) {
    {
    fprintf(_coverage_fout, "5398\n");
    fflush(_coverage_fout);
    ___coverage_array[5398] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = zend_get_property_info_quick(zobj->ce, & member, 1,
                                               (zend_literal const   *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5399] == 0) {
    {
    fprintf(_coverage_fout, "5399\n");
    fflush(_coverage_fout);
    ___coverage_array[5399] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! property_info) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5366] == 0) {
      {
      fprintf(_coverage_fout, "5366\n");
      fflush(_coverage_fout);
      ___coverage_array[5366] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((int __attribute__((__visibility__("default")))  )-1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5367] == 0) {
      {
      fprintf(_coverage_fout, "5367\n");
      fflush(_coverage_fout);
      ___coverage_array[5367] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5400] == 0) {
    {
    fprintf(_coverage_fout, "5400\n");
    fflush(_coverage_fout);
    ___coverage_array[5400] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (class_name) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5392] == 0) {
      {
      fprintf(_coverage_fout, "5392\n");
      fflush(_coverage_fout);
      ___coverage_array[5392] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(class_name + 0) != 42) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5390] == 0) {
        {
        fprintf(_coverage_fout, "5390\n");
        fflush(_coverage_fout);
        ___coverage_array[5390] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! (property_info->flags & 1024U)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5368] == 0) {
          {
          fprintf(_coverage_fout, "5368\n");
          fflush(_coverage_fout);
          ___coverage_array[5368] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((int __attribute__((__visibility__("default")))  )-1);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5388] == 0) {
          {
          fprintf(_coverage_fout, "5388\n");
          fflush(_coverage_fout);
          ___coverage_array[5388] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5380] == 0) {
            {
            fprintf(_coverage_fout, "5380\n");
            fflush(_coverage_fout);
            ___coverage_array[5380] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __s1_len = strlen(prop_info_name + 1);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5381] == 0) {
            {
            fprintf(_coverage_fout, "5381\n");
            fflush(_coverage_fout);
            ___coverage_array[5381] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __s2_len = strlen(property_info->name + 1);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5382] == 0) {
            {
            fprintf(_coverage_fout, "5382\n");
            fflush(_coverage_fout);
            ___coverage_array[5382] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (! ((unsigned int )((void const   *)((prop_info_name + 1) + 1)) - (unsigned int )((void const   *)(prop_info_name + 1)) == 1U)) {
            goto _L___0;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5375] == 0) {
              {
              fprintf(_coverage_fout, "5375\n");
              fflush(_coverage_fout);
              ___coverage_array[5375] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s1_len >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5373] == 0) {
                {
                fprintf(_coverage_fout, "5373\n");
                fflush(_coverage_fout);
                ___coverage_array[5373] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L___0: /* CIL Label */ 
              if (! ((unsigned int )((void const   *)((property_info->name + 1) + 1)) - (unsigned int )((void const   *)(property_info->name + 1)) == 1U)) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5369] == 0) {
                  {
                  fprintf(_coverage_fout, "5369\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5369] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___7 = 1;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5372] == 0) {
                  {
                  fprintf(_coverage_fout, "5372\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5372] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (__s2_len >= 4U) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5370] == 0) {
                    {
                    fprintf(_coverage_fout, "5370\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5370] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  tmp___7 = 1;
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5371] == 0) {
                    {
                    fprintf(_coverage_fout, "5371\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5371] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  tmp___7 = 0;
                }
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5374] == 0) {
                {
                fprintf(_coverage_fout, "5374\n");
                fflush(_coverage_fout);
                ___coverage_array[5374] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___7 = 0;
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5383] == 0) {
            {
            fprintf(_coverage_fout, "5383\n");
            fflush(_coverage_fout);
            ___coverage_array[5383] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___7) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5376] == 0) {
              {
              fprintf(_coverage_fout, "5376\n");
              fflush(_coverage_fout);
              ___coverage_array[5376] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___2 = __builtin_strcmp(prop_info_name + 1,
                                       property_info->name + 1);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5377] == 0) {
              {
              fprintf(_coverage_fout, "5377\n");
              fflush(_coverage_fout);
              ___coverage_array[5377] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___6 = tmp___2;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5378] == 0) {
              {
              fprintf(_coverage_fout, "5378\n");
              fflush(_coverage_fout);
              ___coverage_array[5378] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___5 = __builtin_strcmp(prop_info_name + 1,
                                       property_info->name + 1);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5379] == 0) {
              {
              fprintf(_coverage_fout, "5379\n");
              fflush(_coverage_fout);
              ___coverage_array[5379] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___6 = tmp___5;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5384] == 0) {
            {
            fprintf(_coverage_fout, "5384\n");
            fflush(_coverage_fout);
            ___coverage_array[5384] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___5 = __builtin_strcmp(prop_info_name + 1, property_info->name + 1);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5385] == 0) {
            {
            fprintf(_coverage_fout, "5385\n");
            fflush(_coverage_fout);
            ___coverage_array[5385] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___6 = tmp___5;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5389] == 0) {
          {
          fprintf(_coverage_fout, "5389\n");
          fflush(_coverage_fout);
          ___coverage_array[5389] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___6) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5386] == 0) {
            {
            fprintf(_coverage_fout, "5386\n");
            fflush(_coverage_fout);
            ___coverage_array[5386] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((int __attribute__((__visibility__("default")))  )-1);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5387] == 0) {
            {
            fprintf(_coverage_fout, "5387\n");
            fflush(_coverage_fout);
            ___coverage_array[5387] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5391] == 0) {
        {
        fprintf(_coverage_fout, "5391\n");
        fflush(_coverage_fout);
        ___coverage_array[5391] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5393] == 0) {
      {
      fprintf(_coverage_fout, "5393\n");
      fflush(_coverage_fout);
      ___coverage_array[5393] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5401] == 0) {
    {
    fprintf(_coverage_fout, "5401\n");
    fflush(_coverage_fout);
    ___coverage_array[5401] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___10 = zend_verify_property_access(property_info, zobj->ce);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5402] == 0) {
    {
    fprintf(_coverage_fout, "5402\n");
    fflush(_coverage_fout);
    ___coverage_array[5402] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___10) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5394] == 0) {
      {
      fprintf(_coverage_fout, "5394\n");
      fflush(_coverage_fout);
      ___coverage_array[5394] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = 0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5395] == 0) {
      {
      fprintf(_coverage_fout, "5395\n");
      fflush(_coverage_fout);
      ___coverage_array[5395] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = -1;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5403] == 0) {
    {
    fprintf(_coverage_fout, "5403\n");
    fflush(_coverage_fout);
    ___coverage_array[5403] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )tmp___9);
}
}
static int zend_get_property_guard(zend_object *zobj ,
                                   zend_property_info *property_info ,
                                   zval *member , zend_guard **pguard ) 
{ zend_property_info info ;
  zend_guard stub ;
  ulong __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5417] == 0) {
    {
    fprintf(_coverage_fout, "5417\n");
    fflush(_coverage_fout);
    ___coverage_array[5417] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! property_info) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5404] == 0) {
      {
      fprintf(_coverage_fout, "5404\n");
      fflush(_coverage_fout);
      ___coverage_array[5404] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    property_info = & info;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5405] == 0) {
      {
      fprintf(_coverage_fout, "5405\n");
      fflush(_coverage_fout);
      ___coverage_array[5405] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    info.name = (char const   *)member->value.str.val;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5406] == 0) {
      {
      fprintf(_coverage_fout, "5406\n");
      fflush(_coverage_fout);
      ___coverage_array[5406] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    info.name_length = member->value.str.len;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5407] == 0) {
      {
      fprintf(_coverage_fout, "5407\n");
      fflush(_coverage_fout);
      ___coverage_array[5407] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = zend_get_hash_value((char const   *)member->value.str.val,
                              (unsigned int )(member->value.str.len + 1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5408] == 0) {
      {
      fprintf(_coverage_fout, "5408\n");
      fflush(_coverage_fout);
      ___coverage_array[5408] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    info.h = (unsigned long )tmp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5409] == 0) {
      {
      fprintf(_coverage_fout, "5409\n");
      fflush(_coverage_fout);
      ___coverage_array[5409] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5418] == 0) {
    {
    fprintf(_coverage_fout, "5418\n");
    fflush(_coverage_fout);
    ___coverage_array[5418] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! zobj->guards) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5410] == 0) {
      {
      fprintf(_coverage_fout, "5410\n");
      fflush(_coverage_fout);
      ___coverage_array[5410] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(HashTable ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5411] == 0) {
      {
      fprintf(_coverage_fout, "5411\n");
      fflush(_coverage_fout);
      ___coverage_array[5411] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zobj->guards = (HashTable *)tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5412] == 0) {
      {
      fprintf(_coverage_fout, "5412\n");
      fflush(_coverage_fout);
      ___coverage_array[5412] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_init(zobj->guards, 0U, (ulong (*)(char const   *arKey ,
                                                 uint nKeyLength ))((void *)0),
                    (void (*)(void *pDest ))((void *)0), (unsigned char)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5415] == 0) {
      {
      fprintf(_coverage_fout, "5415\n");
      fflush(_coverage_fout);
      ___coverage_array[5415] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = zend_hash_quick_find((HashTable const   *)zobj->guards,
                                   property_info->name,
                                   (unsigned int )(property_info->name_length + 1),
                                   property_info->h, (void **)pguard);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5416] == 0) {
      {
      fprintf(_coverage_fout, "5416\n");
      fflush(_coverage_fout);
      ___coverage_array[5416] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5413] == 0) {
        {
        fprintf(_coverage_fout, "5413\n");
        fflush(_coverage_fout);
        ___coverage_array[5413] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5414] == 0) {
        {
        fprintf(_coverage_fout, "5414\n");
        fflush(_coverage_fout);
        ___coverage_array[5414] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5419] == 0) {
    {
    fprintf(_coverage_fout, "5419\n");
    fflush(_coverage_fout);
    ___coverage_array[5419] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stub.in_get = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5420] == 0) {
    {
    fprintf(_coverage_fout, "5420\n");
    fflush(_coverage_fout);
    ___coverage_array[5420] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stub.in_set = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5421] == 0) {
    {
    fprintf(_coverage_fout, "5421\n");
    fflush(_coverage_fout);
    ___coverage_array[5421] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stub.in_unset = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5422] == 0) {
    {
    fprintf(_coverage_fout, "5422\n");
    fflush(_coverage_fout);
    ___coverage_array[5422] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stub.in_isset = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5423] == 0) {
    {
    fprintf(_coverage_fout, "5423\n");
    fflush(_coverage_fout);
    ___coverage_array[5423] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = _zend_hash_quick_add_or_update(zobj->guards, property_info->name,
                                           (unsigned int )(property_info->name_length + 1),
                                           property_info->h,
                                           (void *)((void **)(& stub)),
                                           sizeof(stub), (void **)pguard, 1 << 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5424] == 0) {
    {
    fprintf(_coverage_fout, "5424\n");
    fflush(_coverage_fout);
    ___coverage_array[5424] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___2);
}
}
zval *zend_std_read_property(zval *object , zval *member , int type ,
                             zend_literal const   *key ) 
{ zend_object *zobj ;
  zval *tmp_member ;
  zval **retval ;
  zval *rv ;
  zend_property_info *property_info ;
  int silent ;
  void __attribute__((__visibility__("default")))  *tmp ;
  long tmp___0 ;
  zend_guard *guard ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_uint tmp___2 ;
  zend_bool tmp___3 ;
  zval *tmp___4 ;
  void __attribute__((__visibility__("default")))  *tmp___5 ;
  zend_uint tmp___6 ;
  long tmp___7 ;
  zend_bool tmp___8 ;
  long tmp___9 ;
  int tmp___10 ;
  long tmp___11 ;
  long tmp___12 ;
  int tmp___13 ;
  long tmp___14 ;
  int __attribute__((__visibility__("default")))  tmp___15 ;
  long tmp___16 ;
  int tmp___17 ;
  int tmp___18 ;
  long tmp___19 ;
  long tmp___20 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5537] == 0) {
    {
    fprintf(_coverage_fout, "5537\n");
    fflush(_coverage_fout);
    ___coverage_array[5537] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp_member = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5538] == 0) {
    {
    fprintf(_coverage_fout, "5538\n");
    fflush(_coverage_fout);
    ___coverage_array[5538] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  rv = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5539] == 0) {
    {
    fprintf(_coverage_fout, "5539\n");
    fflush(_coverage_fout);
    ___coverage_array[5539] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  silent = type == 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5540] == 0) {
    {
    fprintf(_coverage_fout, "5540\n");
    fflush(_coverage_fout);
    ___coverage_array[5540] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5541] == 0) {
    {
    fprintf(_coverage_fout, "5541\n");
    fflush(_coverage_fout);
    ___coverage_array[5541] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = __builtin_expect((long )((int )member->type != 6), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5542] == 0) {
    {
    fprintf(_coverage_fout, "5542\n");
    fflush(_coverage_fout);
    ___coverage_array[5542] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5430] == 0) {
      {
      fprintf(_coverage_fout, "5430\n");
      fflush(_coverage_fout);
      ___coverage_array[5430] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5425] == 0) {
        {
        fprintf(_coverage_fout, "5425\n");
        fflush(_coverage_fout);
        ___coverage_array[5425] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5426] == 0) {
        {
        fprintf(_coverage_fout, "5426\n");
        fflush(_coverage_fout);
        ___coverage_array[5426] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp_member = (zval *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5427] == 0) {
        {
        fprintf(_coverage_fout, "5427\n");
        fflush(_coverage_fout);
        ___coverage_array[5427] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)tmp_member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5431] == 0) {
      {
      fprintf(_coverage_fout, "5431\n");
      fflush(_coverage_fout);
      ___coverage_array[5431] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5432] == 0) {
      {
      fprintf(_coverage_fout, "5432\n");
      fflush(_coverage_fout);
      ___coverage_array[5432] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5433] == 0) {
      {
      fprintf(_coverage_fout, "5433\n");
      fflush(_coverage_fout);
      ___coverage_array[5433] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5434] == 0) {
      {
      fprintf(_coverage_fout, "5434\n");
      fflush(_coverage_fout);
      ___coverage_array[5434] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5435] == 0) {
      {
      fprintf(_coverage_fout, "5435\n");
      fflush(_coverage_fout);
      ___coverage_array[5435] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )tmp_member->type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5428] == 0) {
        {
        fprintf(_coverage_fout, "5428\n");
        fflush(_coverage_fout);
        ___coverage_array[5428] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5429] == 0) {
        {
        fprintf(_coverage_fout, "5429\n");
        fflush(_coverage_fout);
        ___coverage_array[5429] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5436] == 0) {
      {
      fprintf(_coverage_fout, "5436\n");
      fflush(_coverage_fout);
      ___coverage_array[5436] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = tmp_member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5437] == 0) {
      {
      fprintf(_coverage_fout, "5437\n");
      fflush(_coverage_fout);
      ___coverage_array[5437] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    key = (zend_literal const   *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5438] == 0) {
      {
      fprintf(_coverage_fout, "5438\n");
      fflush(_coverage_fout);
      ___coverage_array[5438] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5543] == 0) {
    {
    fprintf(_coverage_fout, "5543\n");
    fflush(_coverage_fout);
    ___coverage_array[5543] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = zend_get_property_info_quick(zobj->ce, member,
                                               (unsigned int )(zobj->ce)->__get != (unsigned int )((void *)0),
                                               key);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5544] == 0) {
    {
    fprintf(_coverage_fout, "5544\n");
    fflush(_coverage_fout);
    ___coverage_array[5544] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___11 = __builtin_expect((long )(! property_info), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5545] == 0) {
    {
    fprintf(_coverage_fout, "5545\n");
    fflush(_coverage_fout);
    ___coverage_array[5545] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___11) {
    goto _L___3;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5530] == 0) {
      {
      fprintf(_coverage_fout, "5530\n");
      fflush(_coverage_fout);
      ___coverage_array[5530] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___19 = __builtin_expect((long )((property_info->flags & 1U) == 0U), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5531] == 0) {
      {
      fprintf(_coverage_fout, "5531\n");
      fflush(_coverage_fout);
      ___coverage_array[5531] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___19) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5445] == 0) {
        {
        fprintf(_coverage_fout, "5445\n");
        fflush(_coverage_fout);
        ___coverage_array[5445] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (property_info->offset >= 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5443] == 0) {
          {
          fprintf(_coverage_fout, "5443\n");
          fflush(_coverage_fout);
          ___coverage_array[5443] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (zobj->properties) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5439] == 0) {
            {
            fprintf(_coverage_fout, "5439\n");
            fflush(_coverage_fout);
            ___coverage_array[5439] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          retval = (zval **)*(zobj->properties_table + property_info->offset);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5440] == 0) {
            {
            fprintf(_coverage_fout, "5440\n");
            fflush(_coverage_fout);
            ___coverage_array[5440] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___13 = (unsigned int )retval == (unsigned int )((void *)0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5441] == 0) {
            {
            fprintf(_coverage_fout, "5441\n");
            fflush(_coverage_fout);
            ___coverage_array[5441] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          retval = zobj->properties_table + property_info->offset;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5442] == 0) {
            {
            fprintf(_coverage_fout, "5442\n");
            fflush(_coverage_fout);
            ___coverage_array[5442] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___13 = (unsigned int )*retval == (unsigned int )((void *)0);
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5444] == 0) {
          {
          fprintf(_coverage_fout, "5444\n");
          fflush(_coverage_fout);
          ___coverage_array[5444] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___18 = tmp___13;
      } else {
        goto _L___2;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5452] == 0) {
        {
        fprintf(_coverage_fout, "5452\n");
        fflush(_coverage_fout);
        ___coverage_array[5452] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___2: /* CIL Label */ 
      tmp___14 = __builtin_expect((long )(! zobj->properties), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5453] == 0) {
        {
        fprintf(_coverage_fout, "5453\n");
        fflush(_coverage_fout);
        ___coverage_array[5453] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___14) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5446] == 0) {
          {
          fprintf(_coverage_fout, "5446\n");
          fflush(_coverage_fout);
          ___coverage_array[5446] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___17 = 1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5449] == 0) {
          {
          fprintf(_coverage_fout, "5449\n");
          fflush(_coverage_fout);
          ___coverage_array[5449] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___15 = zend_hash_quick_find((HashTable const   *)zobj->properties,
                                        property_info->name,
                                        (unsigned int )(property_info->name_length + 1),
                                        property_info->h, (void **)(& retval));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5450] == 0) {
          {
          fprintf(_coverage_fout, "5450\n");
          fflush(_coverage_fout);
          ___coverage_array[5450] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___16 = __builtin_expect((long )(tmp___15 == (int __attribute__((__visibility__("default")))  )-1),
                                    0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5451] == 0) {
          {
          fprintf(_coverage_fout, "5451\n");
          fflush(_coverage_fout);
          ___coverage_array[5451] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___16) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5447] == 0) {
            {
            fprintf(_coverage_fout, "5447\n");
            fflush(_coverage_fout);
            ___coverage_array[5447] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___17 = 1;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5448] == 0) {
            {
            fprintf(_coverage_fout, "5448\n");
            fflush(_coverage_fout);
            ___coverage_array[5448] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___17 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5454] == 0) {
        {
        fprintf(_coverage_fout, "5454\n");
        fflush(_coverage_fout);
        ___coverage_array[5454] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___18 = tmp___17;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5532] == 0) {
      {
      fprintf(_coverage_fout, "5532\n");
      fflush(_coverage_fout);
      ___coverage_array[5532] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___18) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5527] == 0) {
        {
        fprintf(_coverage_fout, "5527\n");
        fflush(_coverage_fout);
        ___coverage_array[5527] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___3: /* CIL Label */ 
      guard = (zend_guard *)((void *)0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5528] == 0) {
        {
        fprintf(_coverage_fout, "5528\n");
        fflush(_coverage_fout);
        ___coverage_array[5528] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((zobj->ce)->__get) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5510] == 0) {
          {
          fprintf(_coverage_fout, "5510\n");
          fflush(_coverage_fout);
          ___coverage_array[5510] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___10 = zend_get_property_guard(zobj, property_info, member, & guard);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5511] == 0) {
          {
          fprintf(_coverage_fout, "5511\n");
          fflush(_coverage_fout);
          ___coverage_array[5511] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___10 == 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5509] == 0) {
            {
            fprintf(_coverage_fout, "5509\n");
            fflush(_coverage_fout);
            ___coverage_array[5509] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (! guard->in_get) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5500] == 0) {
              {
              fprintf(_coverage_fout, "5500\n");
              fflush(_coverage_fout);
              ___coverage_array[5500] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            zval_addref_p(object);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5501] == 0) {
              {
              fprintf(_coverage_fout, "5501\n");
              fflush(_coverage_fout);
              ___coverage_array[5501] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___3 = zval_isref_p(object);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5502] == 0) {
              {
              fprintf(_coverage_fout, "5502\n");
              fflush(_coverage_fout);
              ___coverage_array[5502] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp___3) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5471] == 0) {
                {
                fprintf(_coverage_fout, "5471\n");
                fflush(_coverage_fout);
                ___coverage_array[5471] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              while (1) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5469] == 0) {
                  {
                  fprintf(_coverage_fout, "5469\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5469] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___2 = zval_refcount_p(object);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5470] == 0) {
                  {
                  fprintf(_coverage_fout, "5470\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5470] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (tmp___2 > 1U) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5463] == 0) {
                    {
                    fprintf(_coverage_fout, "5463\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5463] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zval_delref_p(object);
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5464] == 0) {
                    {
                    fprintf(_coverage_fout, "5464\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5464] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  while (1) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5455] == 0) {
                      {
                      fprintf(_coverage_fout, "5455\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5455] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    tmp___1 = _emalloc(sizeof(zval_gc_info ));
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5456] == 0) {
                      {
                      fprintf(_coverage_fout, "5456\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5456] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    new_zv = (zval *)tmp___1;
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5457] == 0) {
                      {
                      fprintf(_coverage_fout, "5457\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5457] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
                    break;
                  }
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5465] == 0) {
                    {
                    fprintf(_coverage_fout, "5465\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5465] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  while (1) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5460] == 0) {
                      {
                      fprintf(_coverage_fout, "5460\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5460] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    while (1) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5458] == 0) {
                        {
                        fprintf(_coverage_fout, "5458\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5458] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      new_zv->value = object->value;
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5459] == 0) {
                        {
                        fprintf(_coverage_fout, "5459\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5459] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      new_zv->type = object->type;
                      break;
                    }
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5461] == 0) {
                      {
                      fprintf(_coverage_fout, "5461\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5461] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    zval_set_refcount_p(new_zv, 1U);
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5462] == 0) {
                      {
                      fprintf(_coverage_fout, "5462\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5462] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    zval_unset_isref_p(new_zv);
                    break;
                  }
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5466] == 0) {
                    {
                    fprintf(_coverage_fout, "5466\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5466] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  object = new_zv;
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5467] == 0) {
                    {
                    fprintf(_coverage_fout, "5467\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5467] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  _zval_copy_ctor(new_zv);
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5468] == 0) {
                    {
                    fprintf(_coverage_fout, "5468\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5468] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
                break;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5472] == 0) {
                {
                fprintf(_coverage_fout, "5472\n");
                fflush(_coverage_fout);
                ___coverage_array[5472] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5503] == 0) {
              {
              fprintf(_coverage_fout, "5503\n");
              fflush(_coverage_fout);
              ___coverage_array[5503] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            guard->in_get = (unsigned char)1;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5504] == 0) {
              {
              fprintf(_coverage_fout, "5504\n");
              fflush(_coverage_fout);
              ___coverage_array[5504] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            rv = zend_std_call_getter(object, member);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5505] == 0) {
              {
              fprintf(_coverage_fout, "5505\n");
              fflush(_coverage_fout);
              ___coverage_array[5505] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            guard->in_get = (unsigned char)0;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5506] == 0) {
              {
              fprintf(_coverage_fout, "5506\n");
              fflush(_coverage_fout);
              ___coverage_array[5506] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (rv) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5494] == 0) {
                {
                fprintf(_coverage_fout, "5494\n");
                fflush(_coverage_fout);
                ___coverage_array[5494] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              retval = & rv;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5495] == 0) {
                {
                fprintf(_coverage_fout, "5495\n");
                fflush(_coverage_fout);
                ___coverage_array[5495] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___8 = zval_isref_p(rv);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5496] == 0) {
                {
                fprintf(_coverage_fout, "5496\n");
                fflush(_coverage_fout);
                ___coverage_array[5496] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (tmp___8) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5473] == 0) {
                  {
                  fprintf(_coverage_fout, "5473\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5473] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5493] == 0) {
                  {
                  fprintf(_coverage_fout, "5493\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5493] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (type == 1) {
                  goto _L;
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5492] == 0) {
                    {
                    fprintf(_coverage_fout, "5492\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5492] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if (type == 2) {
                    goto _L;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5491] == 0) {
                      {
                      fprintf(_coverage_fout, "5491\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5491] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    if (type == 6) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5486] == 0) {
                        {
                        fprintf(_coverage_fout, "5486\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5486] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      _L: /* CIL Label */ 
                      tmp___6 = zval_refcount_p(rv);
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5487] == 0) {
                        {
                        fprintf(_coverage_fout, "5487\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5487] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if (tmp___6 > 0U) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5477] == 0) {
                          {
                          fprintf(_coverage_fout, "5477\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5477] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        tmp___4 = rv;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5478] == 0) {
                          {
                          fprintf(_coverage_fout, "5478\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5478] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        while (1) {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[5474] == 0) {
                            {
                            fprintf(_coverage_fout, "5474\n");
                            fflush(_coverage_fout);
                            ___coverage_array[5474] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          tmp___5 = _emalloc(sizeof(zval_gc_info ));
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[5475] == 0) {
                            {
                            fprintf(_coverage_fout, "5475\n");
                            fflush(_coverage_fout);
                            ___coverage_array[5475] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          rv = (zval *)tmp___5;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[5476] == 0) {
                            {
                            fprintf(_coverage_fout, "5476\n");
                            fflush(_coverage_fout);
                            ___coverage_array[5476] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          ((zval_gc_info *)rv)->u.buffered = (gc_root_buffer *)((void *)0);
                          break;
                        }
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5479] == 0) {
                          {
                          fprintf(_coverage_fout, "5479\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5479] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        *rv = *tmp___4;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5480] == 0) {
                          {
                          fprintf(_coverage_fout, "5480\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5480] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        _zval_copy_ctor(rv);
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5481] == 0) {
                          {
                          fprintf(_coverage_fout, "5481\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5481] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        zval_unset_isref_p(rv);
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5482] == 0) {
                          {
                          fprintf(_coverage_fout, "5482\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5482] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        zval_set_refcount_p(rv, 0U);
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5483] == 0) {
                          {
                          fprintf(_coverage_fout, "5483\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5483] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }

                      }
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5488] == 0) {
                        {
                        fprintf(_coverage_fout, "5488\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5488] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      tmp___7 = __builtin_expect((long )((int )rv->type != 5),
                                                 0L);
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5489] == 0) {
                        {
                        fprintf(_coverage_fout, "5489\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5489] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if (tmp___7) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5484] == 0) {
                          {
                          fprintf(_coverage_fout, "5484\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5484] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        zend_error(1 << 3L,
                                   "Indirect modification of overloaded property %s::$%s has no effect",
                                   (zobj->ce)->name, member->value.str.val);
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5485] == 0) {
                          {
                          fprintf(_coverage_fout, "5485\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5485] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }

                      }
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5490] == 0) {
                        {
                        fprintf(_coverage_fout, "5490\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5490] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }

                    }
                  }
                }
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5497] == 0) {
                {
                fprintf(_coverage_fout, "5497\n");
                fflush(_coverage_fout);
                ___coverage_array[5497] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              retval = & executor_globals.uninitialized_zval_ptr;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5507] == 0) {
              {
              fprintf(_coverage_fout, "5507\n");
              fflush(_coverage_fout);
              ___coverage_array[5507] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___9 = __builtin_expect((long )((unsigned int )*retval != (unsigned int )object),
                                       1L);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5508] == 0) {
              {
              fprintf(_coverage_fout, "5508\n");
              fflush(_coverage_fout);
              ___coverage_array[5508] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp___9) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5498] == 0) {
                {
                fprintf(_coverage_fout, "5498\n");
                fflush(_coverage_fout);
                ___coverage_array[5498] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _zval_ptr_dtor(& object);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5499] == 0) {
                {
                fprintf(_coverage_fout, "5499\n");
                fflush(_coverage_fout);
                ___coverage_array[5499] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zval_delref_p(object);
            }
          } else {
            goto _L___1;
          }
        } else {
          goto _L___1;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5524] == 0) {
          {
          fprintf(_coverage_fout, "5524\n");
          fflush(_coverage_fout);
          ___coverage_array[5524] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _L___1: /* CIL Label */ 
        _L___0: /* CIL Label */ 
        if ((zobj->ce)->__get) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5520] == 0) {
            {
            fprintf(_coverage_fout, "5520\n");
            fflush(_coverage_fout);
            ___coverage_array[5520] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (guard) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5518] == 0) {
              {
              fprintf(_coverage_fout, "5518\n");
              fflush(_coverage_fout);
              ___coverage_array[5518] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int )guard->in_get == 1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5516] == 0) {
                {
                fprintf(_coverage_fout, "5516\n");
                fflush(_coverage_fout);
                ___coverage_array[5516] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int )*(member->value.str.val + 0) == 0) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5514] == 0) {
                  {
                  fprintf(_coverage_fout, "5514\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5514] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (member->value.str.len == 0) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5512] == 0) {
                    {
                    fprintf(_coverage_fout, "5512\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5512] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zend_error(1, "Cannot access empty property");
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5513] == 0) {
                    {
                    fprintf(_coverage_fout, "5513\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5513] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zend_error(1, "Cannot access property started with \'\\0\'");
                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5515] == 0) {
                  {
                  fprintf(_coverage_fout, "5515\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5515] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5517] == 0) {
                {
                fprintf(_coverage_fout, "5517\n");
                fflush(_coverage_fout);
                ___coverage_array[5517] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5519] == 0) {
              {
              fprintf(_coverage_fout, "5519\n");
              fflush(_coverage_fout);
              ___coverage_array[5519] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5521] == 0) {
            {
            fprintf(_coverage_fout, "5521\n");
            fflush(_coverage_fout);
            ___coverage_array[5521] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5525] == 0) {
          {
          fprintf(_coverage_fout, "5525\n");
          fflush(_coverage_fout);
          ___coverage_array[5525] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! silent) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5522] == 0) {
            {
            fprintf(_coverage_fout, "5522\n");
            fflush(_coverage_fout);
            ___coverage_array[5522] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error(1 << 3L, "Undefined property: %s::$%s", (zobj->ce)->name,
                     member->value.str.val);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5523] == 0) {
            {
            fprintf(_coverage_fout, "5523\n");
            fflush(_coverage_fout);
            ___coverage_array[5523] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5526] == 0) {
          {
          fprintf(_coverage_fout, "5526\n");
          fflush(_coverage_fout);
          ___coverage_array[5526] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        retval = & executor_globals.uninitialized_zval_ptr;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5529] == 0) {
        {
        fprintf(_coverage_fout, "5529\n");
        fflush(_coverage_fout);
        ___coverage_array[5529] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5546] == 0) {
    {
    fprintf(_coverage_fout, "5546\n");
    fflush(_coverage_fout);
    ___coverage_array[5546] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___20 = __builtin_expect((long )((unsigned int )tmp_member != (unsigned int )((void *)0)),
                              0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5547] == 0) {
    {
    fprintf(_coverage_fout, "5547\n");
    fflush(_coverage_fout);
    ___coverage_array[5547] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___20) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5533] == 0) {
      {
      fprintf(_coverage_fout, "5533\n");
      fflush(_coverage_fout);
      ___coverage_array[5533] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_addref_p(*retval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5534] == 0) {
      {
      fprintf(_coverage_fout, "5534\n");
      fflush(_coverage_fout);
      ___coverage_array[5534] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5535] == 0) {
      {
      fprintf(_coverage_fout, "5535\n");
      fflush(_coverage_fout);
      ___coverage_array[5535] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_delref_p(*retval);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5536] == 0) {
      {
      fprintf(_coverage_fout, "5536\n");
      fflush(_coverage_fout);
      ___coverage_array[5536] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5548] == 0) {
    {
    fprintf(_coverage_fout, "5548\n");
    fflush(_coverage_fout);
    ___coverage_array[5548] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (*retval);
}
}
void __attribute__((__visibility__("default")))  zend_std_write_property(zval *object ,
                                                                         zval *member ,
                                                                         zval *value ,
                                                                         struct _zend_literal  const  *key ) 
{ zend_object *zobj ;
  zval *tmp_member ;
  zval **variable_ptr ;
  zend_property_info *property_info ;
  void __attribute__((__visibility__("default")))  *tmp ;
  long tmp___0 ;
  zval garbage ;
  zend_uint tmp___1 ;
  zval *garbage___0 ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;
  zend_uint tmp___3 ;
  zend_bool tmp___4 ;
  zend_bool tmp___5 ;
  long tmp___6 ;
  zend_guard *guard ;
  zval *new_zv___0 ;
  void __attribute__((__visibility__("default")))  *tmp___7 ;
  zend_uint tmp___8 ;
  zend_bool tmp___9 ;
  int tmp___10 ;
  zval *new_zv___1 ;
  void __attribute__((__visibility__("default")))  *tmp___11 ;
  zend_uint tmp___12 ;
  zend_bool tmp___13 ;
  long tmp___14 ;
  long tmp___15 ;
  int tmp___16 ;
  long tmp___17 ;
  long tmp___18 ;
  int tmp___19 ;
  long tmp___20 ;
  int __attribute__((__visibility__("default")))  tmp___21 ;
  long tmp___22 ;
  int tmp___23 ;
  int tmp___24 ;
  long tmp___25 ;
  long tmp___26 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5700] == 0) {
    {
    fprintf(_coverage_fout, "5700\n");
    fflush(_coverage_fout);
    ___coverage_array[5700] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp_member = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5701] == 0) {
    {
    fprintf(_coverage_fout, "5701\n");
    fflush(_coverage_fout);
    ___coverage_array[5701] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5702] == 0) {
    {
    fprintf(_coverage_fout, "5702\n");
    fflush(_coverage_fout);
    ___coverage_array[5702] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = __builtin_expect((long )((int )member->type != 6), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5703] == 0) {
    {
    fprintf(_coverage_fout, "5703\n");
    fflush(_coverage_fout);
    ___coverage_array[5703] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5554] == 0) {
      {
      fprintf(_coverage_fout, "5554\n");
      fflush(_coverage_fout);
      ___coverage_array[5554] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5549] == 0) {
        {
        fprintf(_coverage_fout, "5549\n");
        fflush(_coverage_fout);
        ___coverage_array[5549] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5550] == 0) {
        {
        fprintf(_coverage_fout, "5550\n");
        fflush(_coverage_fout);
        ___coverage_array[5550] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp_member = (zval *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5551] == 0) {
        {
        fprintf(_coverage_fout, "5551\n");
        fflush(_coverage_fout);
        ___coverage_array[5551] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)tmp_member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5555] == 0) {
      {
      fprintf(_coverage_fout, "5555\n");
      fflush(_coverage_fout);
      ___coverage_array[5555] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5556] == 0) {
      {
      fprintf(_coverage_fout, "5556\n");
      fflush(_coverage_fout);
      ___coverage_array[5556] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5557] == 0) {
      {
      fprintf(_coverage_fout, "5557\n");
      fflush(_coverage_fout);
      ___coverage_array[5557] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5558] == 0) {
      {
      fprintf(_coverage_fout, "5558\n");
      fflush(_coverage_fout);
      ___coverage_array[5558] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5559] == 0) {
      {
      fprintf(_coverage_fout, "5559\n");
      fflush(_coverage_fout);
      ___coverage_array[5559] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )tmp_member->type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5552] == 0) {
        {
        fprintf(_coverage_fout, "5552\n");
        fflush(_coverage_fout);
        ___coverage_array[5552] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5553] == 0) {
        {
        fprintf(_coverage_fout, "5553\n");
        fflush(_coverage_fout);
        ___coverage_array[5553] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5560] == 0) {
      {
      fprintf(_coverage_fout, "5560\n");
      fflush(_coverage_fout);
      ___coverage_array[5560] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = tmp_member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5561] == 0) {
      {
      fprintf(_coverage_fout, "5561\n");
      fflush(_coverage_fout);
      ___coverage_array[5561] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    key = (struct _zend_literal  const  *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5562] == 0) {
      {
      fprintf(_coverage_fout, "5562\n");
      fflush(_coverage_fout);
      ___coverage_array[5562] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5704] == 0) {
    {
    fprintf(_coverage_fout, "5704\n");
    fflush(_coverage_fout);
    ___coverage_array[5704] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = zend_get_property_info_quick(zobj->ce, member,
                                               (unsigned int )(zobj->ce)->__set != (unsigned int )((void *)0),
                                               key);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5705] == 0) {
    {
    fprintf(_coverage_fout, "5705\n");
    fflush(_coverage_fout);
    ___coverage_array[5705] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___17 = __builtin_expect((long )((unsigned int )property_info != (unsigned int )((void *)0)),
                              1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5706] == 0) {
    {
    fprintf(_coverage_fout, "5706\n");
    fflush(_coverage_fout);
    ___coverage_array[5706] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___17) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5616] == 0) {
      {
      fprintf(_coverage_fout, "5616\n");
      fflush(_coverage_fout);
      ___coverage_array[5616] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___25 = __builtin_expect((long )((property_info->flags & 1U) == 0U), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5617] == 0) {
      {
      fprintf(_coverage_fout, "5617\n");
      fflush(_coverage_fout);
      ___coverage_array[5617] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___25) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5569] == 0) {
        {
        fprintf(_coverage_fout, "5569\n");
        fflush(_coverage_fout);
        ___coverage_array[5569] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (property_info->offset >= 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5567] == 0) {
          {
          fprintf(_coverage_fout, "5567\n");
          fflush(_coverage_fout);
          ___coverage_array[5567] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (zobj->properties) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5563] == 0) {
            {
            fprintf(_coverage_fout, "5563\n");
            fflush(_coverage_fout);
            ___coverage_array[5563] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          variable_ptr = (zval **)*(zobj->properties_table + property_info->offset);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5564] == 0) {
            {
            fprintf(_coverage_fout, "5564\n");
            fflush(_coverage_fout);
            ___coverage_array[5564] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___19 = (unsigned int )variable_ptr != (unsigned int )((void *)0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5565] == 0) {
            {
            fprintf(_coverage_fout, "5565\n");
            fflush(_coverage_fout);
            ___coverage_array[5565] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          variable_ptr = zobj->properties_table + property_info->offset;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5566] == 0) {
            {
            fprintf(_coverage_fout, "5566\n");
            fflush(_coverage_fout);
            ___coverage_array[5566] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___19 = (unsigned int )*variable_ptr != (unsigned int )((void *)0);
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5568] == 0) {
          {
          fprintf(_coverage_fout, "5568\n");
          fflush(_coverage_fout);
          ___coverage_array[5568] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___24 = tmp___19;
      } else {
        goto _L___2;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5576] == 0) {
        {
        fprintf(_coverage_fout, "5576\n");
        fflush(_coverage_fout);
        ___coverage_array[5576] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___2: /* CIL Label */ 
      tmp___20 = __builtin_expect((long )((unsigned int )zobj->properties != (unsigned int )((void *)0)),
                                  1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5577] == 0) {
        {
        fprintf(_coverage_fout, "5577\n");
        fflush(_coverage_fout);
        ___coverage_array[5577] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___20) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5572] == 0) {
          {
          fprintf(_coverage_fout, "5572\n");
          fflush(_coverage_fout);
          ___coverage_array[5572] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___21 = zend_hash_quick_find((HashTable const   *)zobj->properties,
                                        property_info->name,
                                        (unsigned int )(property_info->name_length + 1),
                                        property_info->h,
                                        (void **)(& variable_ptr));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5573] == 0) {
          {
          fprintf(_coverage_fout, "5573\n");
          fflush(_coverage_fout);
          ___coverage_array[5573] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___22 = __builtin_expect((long )(tmp___21 == (int __attribute__((__visibility__("default")))  )0),
                                    1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5574] == 0) {
          {
          fprintf(_coverage_fout, "5574\n");
          fflush(_coverage_fout);
          ___coverage_array[5574] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___22) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5570] == 0) {
            {
            fprintf(_coverage_fout, "5570\n");
            fflush(_coverage_fout);
            ___coverage_array[5570] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___23 = 1;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5571] == 0) {
            {
            fprintf(_coverage_fout, "5571\n");
            fflush(_coverage_fout);
            ___coverage_array[5571] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___23 = 0;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5575] == 0) {
          {
          fprintf(_coverage_fout, "5575\n");
          fflush(_coverage_fout);
          ___coverage_array[5575] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___23 = 0;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5578] == 0) {
        {
        fprintf(_coverage_fout, "5578\n");
        fflush(_coverage_fout);
        ___coverage_array[5578] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___24 = tmp___23;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5618] == 0) {
      {
      fprintf(_coverage_fout, "5618\n");
      fflush(_coverage_fout);
      ___coverage_array[5618] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___24) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5614] == 0) {
        {
        fprintf(_coverage_fout, "5614\n");
        fflush(_coverage_fout);
        ___coverage_array[5614] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = __builtin_expect((long )((unsigned int )*variable_ptr != (unsigned int )value),
                                 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5615] == 0) {
        {
        fprintf(_coverage_fout, "5615\n");
        fflush(_coverage_fout);
        ___coverage_array[5615] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___6) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5611] == 0) {
          {
          fprintf(_coverage_fout, "5611\n");
          fflush(_coverage_fout);
          ___coverage_array[5611] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = zval_isref_p(*variable_ptr);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5612] == 0) {
          {
          fprintf(_coverage_fout, "5612\n");
          fflush(_coverage_fout);
          ___coverage_array[5612] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___5) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5581] == 0) {
            {
            fprintf(_coverage_fout, "5581\n");
            fflush(_coverage_fout);
            ___coverage_array[5581] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          garbage = *(*variable_ptr);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5582] == 0) {
            {
            fprintf(_coverage_fout, "5582\n");
            fflush(_coverage_fout);
            ___coverage_array[5582] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          (*variable_ptr)->type = value->type;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5583] == 0) {
            {
            fprintf(_coverage_fout, "5583\n");
            fflush(_coverage_fout);
            ___coverage_array[5583] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          (*variable_ptr)->value = value->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5584] == 0) {
            {
            fprintf(_coverage_fout, "5584\n");
            fflush(_coverage_fout);
            ___coverage_array[5584] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = zval_refcount_p(value);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5585] == 0) {
            {
            fprintf(_coverage_fout, "5585\n");
            fflush(_coverage_fout);
            ___coverage_array[5585] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___1 > 0U) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5579] == 0) {
              {
              fprintf(_coverage_fout, "5579\n");
              fflush(_coverage_fout);
              ___coverage_array[5579] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_copy_ctor(*variable_ptr);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5580] == 0) {
              {
              fprintf(_coverage_fout, "5580\n");
              fflush(_coverage_fout);
              ___coverage_array[5580] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5586] == 0) {
            {
            fprintf(_coverage_fout, "5586\n");
            fflush(_coverage_fout);
            ___coverage_array[5586] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zval_dtor(& garbage);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5605] == 0) {
            {
            fprintf(_coverage_fout, "5605\n");
            fflush(_coverage_fout);
            ___coverage_array[5605] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          garbage___0 = *variable_ptr;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5606] == 0) {
            {
            fprintf(_coverage_fout, "5606\n");
            fflush(_coverage_fout);
            ___coverage_array[5606] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_addref_p(value);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5607] == 0) {
            {
            fprintf(_coverage_fout, "5607\n");
            fflush(_coverage_fout);
            ___coverage_array[5607] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___4 = zval_isref_p(value);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5608] == 0) {
            {
            fprintf(_coverage_fout, "5608\n");
            fflush(_coverage_fout);
            ___coverage_array[5608] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___4) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5603] == 0) {
              {
              fprintf(_coverage_fout, "5603\n");
              fflush(_coverage_fout);
              ___coverage_array[5603] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            while (1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5601] == 0) {
                {
                fprintf(_coverage_fout, "5601\n");
                fflush(_coverage_fout);
                ___coverage_array[5601] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___3 = zval_refcount_p(value);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5602] == 0) {
                {
                fprintf(_coverage_fout, "5602\n");
                fflush(_coverage_fout);
                ___coverage_array[5602] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (tmp___3 > 1U) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5595] == 0) {
                  {
                  fprintf(_coverage_fout, "5595\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5595] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                zval_delref_p(value);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5596] == 0) {
                  {
                  fprintf(_coverage_fout, "5596\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5596] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                while (1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5587] == 0) {
                    {
                    fprintf(_coverage_fout, "5587\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5587] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  tmp___2 = _emalloc(sizeof(zval_gc_info ));
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5588] == 0) {
                    {
                    fprintf(_coverage_fout, "5588\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5588] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  new_zv = (zval *)tmp___2;
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5589] == 0) {
                    {
                    fprintf(_coverage_fout, "5589\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5589] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
                  break;
                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5597] == 0) {
                  {
                  fprintf(_coverage_fout, "5597\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5597] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                while (1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5592] == 0) {
                    {
                    fprintf(_coverage_fout, "5592\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5592] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  while (1) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5590] == 0) {
                      {
                      fprintf(_coverage_fout, "5590\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5590] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    new_zv->value = value->value;
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5591] == 0) {
                      {
                      fprintf(_coverage_fout, "5591\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5591] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    new_zv->type = value->type;
                    break;
                  }
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5593] == 0) {
                    {
                    fprintf(_coverage_fout, "5593\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5593] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zval_set_refcount_p(new_zv, 1U);
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5594] == 0) {
                    {
                    fprintf(_coverage_fout, "5594\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5594] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zval_unset_isref_p(new_zv);
                  break;
                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5598] == 0) {
                  {
                  fprintf(_coverage_fout, "5598\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5598] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                value = new_zv;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5599] == 0) {
                  {
                  fprintf(_coverage_fout, "5599\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5599] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _zval_copy_ctor(new_zv);
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5600] == 0) {
                  {
                  fprintf(_coverage_fout, "5600\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5600] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              break;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5604] == 0) {
              {
              fprintf(_coverage_fout, "5604\n");
              fflush(_coverage_fout);
              ___coverage_array[5604] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5609] == 0) {
            {
            fprintf(_coverage_fout, "5609\n");
            fflush(_coverage_fout);
            ___coverage_array[5609] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *variable_ptr = value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5610] == 0) {
            {
            fprintf(_coverage_fout, "5610\n");
            fflush(_coverage_fout);
            ___coverage_array[5610] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zval_ptr_dtor(& garbage___0);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5613] == 0) {
          {
          fprintf(_coverage_fout, "5613\n");
          fflush(_coverage_fout);
          ___coverage_array[5613] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      goto _L___3;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5696] == 0) {
      {
      fprintf(_coverage_fout, "5696\n");
      fflush(_coverage_fout);
      ___coverage_array[5696] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L___3: /* CIL Label */ 
    guard = (zend_guard *)((void *)0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5697] == 0) {
      {
      fprintf(_coverage_fout, "5697\n");
      fflush(_coverage_fout);
      ___coverage_array[5697] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((zobj->ce)->__set) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5648] == 0) {
        {
        fprintf(_coverage_fout, "5648\n");
        fflush(_coverage_fout);
        ___coverage_array[5648] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___16 = zend_get_property_guard(zobj, property_info, member, & guard);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5649] == 0) {
        {
        fprintf(_coverage_fout, "5649\n");
        fflush(_coverage_fout);
        ___coverage_array[5649] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___16 == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5647] == 0) {
          {
          fprintf(_coverage_fout, "5647\n");
          fflush(_coverage_fout);
          ___coverage_array[5647] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! guard->in_set) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5639] == 0) {
            {
            fprintf(_coverage_fout, "5639\n");
            fflush(_coverage_fout);
            ___coverage_array[5639] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_addref_p(object);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5640] == 0) {
            {
            fprintf(_coverage_fout, "5640\n");
            fflush(_coverage_fout);
            ___coverage_array[5640] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = zval_isref_p(object);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5641] == 0) {
            {
            fprintf(_coverage_fout, "5641\n");
            fflush(_coverage_fout);
            ___coverage_array[5641] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___9) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5635] == 0) {
              {
              fprintf(_coverage_fout, "5635\n");
              fflush(_coverage_fout);
              ___coverage_array[5635] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            while (1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5633] == 0) {
                {
                fprintf(_coverage_fout, "5633\n");
                fflush(_coverage_fout);
                ___coverage_array[5633] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___8 = zval_refcount_p(object);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5634] == 0) {
                {
                fprintf(_coverage_fout, "5634\n");
                fflush(_coverage_fout);
                ___coverage_array[5634] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (tmp___8 > 1U) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5627] == 0) {
                  {
                  fprintf(_coverage_fout, "5627\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5627] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                zval_delref_p(object);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5628] == 0) {
                  {
                  fprintf(_coverage_fout, "5628\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5628] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                while (1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5619] == 0) {
                    {
                    fprintf(_coverage_fout, "5619\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5619] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  tmp___7 = _emalloc(sizeof(zval_gc_info ));
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5620] == 0) {
                    {
                    fprintf(_coverage_fout, "5620\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5620] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  new_zv___0 = (zval *)tmp___7;
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5621] == 0) {
                    {
                    fprintf(_coverage_fout, "5621\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5621] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  ((zval_gc_info *)new_zv___0)->u.buffered = (gc_root_buffer *)((void *)0);
                  break;
                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5629] == 0) {
                  {
                  fprintf(_coverage_fout, "5629\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5629] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                while (1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5624] == 0) {
                    {
                    fprintf(_coverage_fout, "5624\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5624] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  while (1) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5622] == 0) {
                      {
                      fprintf(_coverage_fout, "5622\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5622] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    new_zv___0->value = object->value;
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5623] == 0) {
                      {
                      fprintf(_coverage_fout, "5623\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5623] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    new_zv___0->type = object->type;
                    break;
                  }
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5625] == 0) {
                    {
                    fprintf(_coverage_fout, "5625\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5625] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zval_set_refcount_p(new_zv___0, 1U);
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5626] == 0) {
                    {
                    fprintf(_coverage_fout, "5626\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5626] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zval_unset_isref_p(new_zv___0);
                  break;
                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5630] == 0) {
                  {
                  fprintf(_coverage_fout, "5630\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5630] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                object = new_zv___0;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5631] == 0) {
                  {
                  fprintf(_coverage_fout, "5631\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5631] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _zval_copy_ctor(new_zv___0);
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5632] == 0) {
                  {
                  fprintf(_coverage_fout, "5632\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5632] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              break;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5636] == 0) {
              {
              fprintf(_coverage_fout, "5636\n");
              fflush(_coverage_fout);
              ___coverage_array[5636] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5642] == 0) {
            {
            fprintf(_coverage_fout, "5642\n");
            fflush(_coverage_fout);
            ___coverage_array[5642] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          guard->in_set = (unsigned char)1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5643] == 0) {
            {
            fprintf(_coverage_fout, "5643\n");
            fflush(_coverage_fout);
            ___coverage_array[5643] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = zend_std_call_setter(object, member, value);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5644] == 0) {
            {
            fprintf(_coverage_fout, "5644\n");
            fflush(_coverage_fout);
            ___coverage_array[5644] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___10 != 0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5637] == 0) {
              {
              fprintf(_coverage_fout, "5637\n");
              fflush(_coverage_fout);
              ___coverage_array[5637] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5638] == 0) {
              {
              fprintf(_coverage_fout, "5638\n");
              fflush(_coverage_fout);
              ___coverage_array[5638] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5645] == 0) {
            {
            fprintf(_coverage_fout, "5645\n");
            fflush(_coverage_fout);
            ___coverage_array[5645] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          guard->in_set = (unsigned char)0;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5646] == 0) {
            {
            fprintf(_coverage_fout, "5646\n");
            fflush(_coverage_fout);
            ___coverage_array[5646] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zval_ptr_dtor(& object);
        } else {
          goto _L___1;
        }
      } else {
        goto _L___1;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5694] == 0) {
        {
        fprintf(_coverage_fout, "5694\n");
        fflush(_coverage_fout);
        ___coverage_array[5694] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___1: /* CIL Label */ 
      _L___0: /* CIL Label */ 
      tmp___15 = __builtin_expect((long )((unsigned int )property_info != (unsigned int )((void *)0)),
                                  1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5695] == 0) {
        {
        fprintf(_coverage_fout, "5695\n");
        fflush(_coverage_fout);
        ___coverage_array[5695] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___15) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5678] == 0) {
          {
          fprintf(_coverage_fout, "5678\n");
          fflush(_coverage_fout);
          ___coverage_array[5678] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_addref_p(value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5679] == 0) {
          {
          fprintf(_coverage_fout, "5679\n");
          fflush(_coverage_fout);
          ___coverage_array[5679] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___13 = zval_isref_p(value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5680] == 0) {
          {
          fprintf(_coverage_fout, "5680\n");
          fflush(_coverage_fout);
          ___coverage_array[5680] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___13) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5666] == 0) {
            {
            fprintf(_coverage_fout, "5666\n");
            fflush(_coverage_fout);
            ___coverage_array[5666] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5664] == 0) {
              {
              fprintf(_coverage_fout, "5664\n");
              fflush(_coverage_fout);
              ___coverage_array[5664] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___12 = zval_refcount_p(value);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5665] == 0) {
              {
              fprintf(_coverage_fout, "5665\n");
              fflush(_coverage_fout);
              ___coverage_array[5665] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp___12 > 1U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5658] == 0) {
                {
                fprintf(_coverage_fout, "5658\n");
                fflush(_coverage_fout);
                ___coverage_array[5658] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zval_delref_p(value);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5659] == 0) {
                {
                fprintf(_coverage_fout, "5659\n");
                fflush(_coverage_fout);
                ___coverage_array[5659] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              while (1) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5650] == 0) {
                  {
                  fprintf(_coverage_fout, "5650\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5650] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___11 = _emalloc(sizeof(zval_gc_info ));
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5651] == 0) {
                  {
                  fprintf(_coverage_fout, "5651\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5651] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                new_zv___1 = (zval *)tmp___11;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5652] == 0) {
                  {
                  fprintf(_coverage_fout, "5652\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5652] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                ((zval_gc_info *)new_zv___1)->u.buffered = (gc_root_buffer *)((void *)0);
                break;
              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5660] == 0) {
                {
                fprintf(_coverage_fout, "5660\n");
                fflush(_coverage_fout);
                ___coverage_array[5660] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              while (1) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5655] == 0) {
                  {
                  fprintf(_coverage_fout, "5655\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5655] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                while (1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5653] == 0) {
                    {
                    fprintf(_coverage_fout, "5653\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5653] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  new_zv___1->value = value->value;
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5654] == 0) {
                    {
                    fprintf(_coverage_fout, "5654\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5654] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  new_zv___1->type = value->type;
                  break;
                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5656] == 0) {
                  {
                  fprintf(_coverage_fout, "5656\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5656] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                zval_set_refcount_p(new_zv___1, 1U);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5657] == 0) {
                  {
                  fprintf(_coverage_fout, "5657\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5657] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                zval_unset_isref_p(new_zv___1);
                break;
              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5661] == 0) {
                {
                fprintf(_coverage_fout, "5661\n");
                fflush(_coverage_fout);
                ___coverage_array[5661] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              value = new_zv___1;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5662] == 0) {
                {
                fprintf(_coverage_fout, "5662\n");
                fflush(_coverage_fout);
                ___coverage_array[5662] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _zval_copy_ctor(new_zv___1);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5663] == 0) {
                {
                fprintf(_coverage_fout, "5663\n");
                fflush(_coverage_fout);
                ___coverage_array[5663] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
            break;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5667] == 0) {
            {
            fprintf(_coverage_fout, "5667\n");
            fflush(_coverage_fout);
            ___coverage_array[5667] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5681] == 0) {
          {
          fprintf(_coverage_fout, "5681\n");
          fflush(_coverage_fout);
          ___coverage_array[5681] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___14 = __builtin_expect((long )((property_info->flags & 1U) == 0U),
                                    1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5682] == 0) {
          {
          fprintf(_coverage_fout, "5682\n");
          fflush(_coverage_fout);
          ___coverage_array[5682] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___14) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5673] == 0) {
            {
            fprintf(_coverage_fout, "5673\n");
            fflush(_coverage_fout);
            ___coverage_array[5673] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (property_info->offset >= 0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5672] == 0) {
              {
              fprintf(_coverage_fout, "5672\n");
              fflush(_coverage_fout);
              ___coverage_array[5672] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (! zobj->properties) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5668] == 0) {
                {
                fprintf(_coverage_fout, "5668\n");
                fflush(_coverage_fout);
                ___coverage_array[5668] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              *(zobj->properties_table + property_info->offset) = value;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5671] == 0) {
                {
                fprintf(_coverage_fout, "5671\n");
                fflush(_coverage_fout);
                ___coverage_array[5671] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (*(zobj->properties_table + property_info->offset)) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5669] == 0) {
                  {
                  fprintf(_coverage_fout, "5669\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5669] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                *((zval **)*(zobj->properties_table + property_info->offset)) = value;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5670] == 0) {
                  {
                  fprintf(_coverage_fout, "5670\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5670] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _zend_hash_quick_add_or_update(zobj->properties,
                                               property_info->name,
                                               (unsigned int )(property_info->name_length + 1),
                                               property_info->h,
                                               (void *)(& value),
                                               sizeof(zval *),
                                               (void **)(zobj->properties_table + property_info->offset),
                                               1);
              }
            }
          } else {
            goto _L;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5676] == 0) {
            {
            fprintf(_coverage_fout, "5676\n");
            fflush(_coverage_fout);
            ___coverage_array[5676] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L: /* CIL Label */ 
          if (! zobj->properties) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5674] == 0) {
              {
              fprintf(_coverage_fout, "5674\n");
              fflush(_coverage_fout);
              ___coverage_array[5674] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            rebuild_object_properties(zobj);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5675] == 0) {
              {
              fprintf(_coverage_fout, "5675\n");
              fflush(_coverage_fout);
              ___coverage_array[5675] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5677] == 0) {
            {
            fprintf(_coverage_fout, "5677\n");
            fflush(_coverage_fout);
            ___coverage_array[5677] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zend_hash_quick_add_or_update(zobj->properties, property_info->name,
                                         (unsigned int )(property_info->name_length + 1),
                                         property_info->h, (void *)(& value),
                                         sizeof(zval *), (void **)((void *)0), 1);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5693] == 0) {
          {
          fprintf(_coverage_fout, "5693\n");
          fflush(_coverage_fout);
          ___coverage_array[5693] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((zobj->ce)->__set) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5691] == 0) {
            {
            fprintf(_coverage_fout, "5691\n");
            fflush(_coverage_fout);
            ___coverage_array[5691] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (guard) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5689] == 0) {
              {
              fprintf(_coverage_fout, "5689\n");
              fflush(_coverage_fout);
              ___coverage_array[5689] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int )guard->in_set == 1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5687] == 0) {
                {
                fprintf(_coverage_fout, "5687\n");
                fflush(_coverage_fout);
                ___coverage_array[5687] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int )*(member->value.str.val + 0) == 0) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5685] == 0) {
                  {
                  fprintf(_coverage_fout, "5685\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5685] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (member->value.str.len == 0) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5683] == 0) {
                    {
                    fprintf(_coverage_fout, "5683\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5683] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zend_error(1, "Cannot access empty property");
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5684] == 0) {
                    {
                    fprintf(_coverage_fout, "5684\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5684] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  zend_error(1, "Cannot access property started with \'\\0\'");
                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5686] == 0) {
                  {
                  fprintf(_coverage_fout, "5686\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5686] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5688] == 0) {
                {
                fprintf(_coverage_fout, "5688\n");
                fflush(_coverage_fout);
                ___coverage_array[5688] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5690] == 0) {
              {
              fprintf(_coverage_fout, "5690\n");
              fflush(_coverage_fout);
              ___coverage_array[5690] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5692] == 0) {
            {
            fprintf(_coverage_fout, "5692\n");
            fflush(_coverage_fout);
            ___coverage_array[5692] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5707] == 0) {
    {
    fprintf(_coverage_fout, "5707\n");
    fflush(_coverage_fout);
    ___coverage_array[5707] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___26 = __builtin_expect((long )((unsigned int )tmp_member != (unsigned int )((void *)0)),
                              0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5708] == 0) {
    {
    fprintf(_coverage_fout, "5708\n");
    fflush(_coverage_fout);
    ___coverage_array[5708] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___26) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5698] == 0) {
      {
      fprintf(_coverage_fout, "5698\n");
      fflush(_coverage_fout);
      ___coverage_array[5698] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& tmp_member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5699] == 0) {
      {
      fprintf(_coverage_fout, "5699\n");
      fflush(_coverage_fout);
      ___coverage_array[5699] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5709] == 0) {
    {
    fprintf(_coverage_fout, "5709\n");
    fflush(_coverage_fout);
    ___coverage_array[5709] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
zval *zend_std_read_dimension(zval *object , zval *offset , int type ) 
{ zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *retval ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_bool tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___5 ;
  long tmp___6 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5745] == 0) {
    {
    fprintf(_coverage_fout, "5745\n");
    fflush(_coverage_fout);
    ___coverage_array[5745] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5746] == 0) {
    {
    fprintf(_coverage_fout, "5746\n");
    fflush(_coverage_fout);
    ___coverage_array[5746] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5747] == 0) {
    {
    fprintf(_coverage_fout, "5747\n");
    fflush(_coverage_fout);
    ___coverage_array[5747] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = instanceof_function_ex((zend_class_entry const   *)ce,
                                   (zend_class_entry const   *)zend_ce_arrayaccess,
                                   (unsigned char)1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5748] == 0) {
    {
    fprintf(_coverage_fout, "5748\n");
    fflush(_coverage_fout);
    ___coverage_array[5748] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___6 = __builtin_expect((long )((int __attribute__((__visibility__("default")))  )tmp___5 != (int __attribute__((__visibility__("default")))  )0),
                             1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5749] == 0) {
    {
    fprintf(_coverage_fout, "5749\n");
    fflush(_coverage_fout);
    ___coverage_array[5749] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___6) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5736] == 0) {
      {
      fprintf(_coverage_fout, "5736\n");
      fflush(_coverage_fout);
      ___coverage_array[5736] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )offset == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5713] == 0) {
        {
        fprintf(_coverage_fout, "5713\n");
        fflush(_coverage_fout);
        ___coverage_array[5713] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5710] == 0) {
          {
          fprintf(_coverage_fout, "5710\n");
          fflush(_coverage_fout);
          ___coverage_array[5710] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5711] == 0) {
          {
          fprintf(_coverage_fout, "5711\n");
          fflush(_coverage_fout);
          ___coverage_array[5711] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = (zval *)tmp___0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5712] == 0) {
          {
          fprintf(_coverage_fout, "5712\n");
          fflush(_coverage_fout);
          ___coverage_array[5712] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)offset)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5714] == 0) {
        {
        fprintf(_coverage_fout, "5714\n");
        fflush(_coverage_fout);
        ___coverage_array[5714] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *offset = (struct _zval_struct )zval_used_for_init;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5728] == 0) {
        {
        fprintf(_coverage_fout, "5728\n");
        fflush(_coverage_fout);
        ___coverage_array[5728] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = zval_isref_p(offset);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5729] == 0) {
        {
        fprintf(_coverage_fout, "5729\n");
        fflush(_coverage_fout);
        ___coverage_array[5729] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5723] == 0) {
          {
          fprintf(_coverage_fout, "5723\n");
          fflush(_coverage_fout);
          ___coverage_array[5723] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        original_var = offset;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5724] == 0) {
          {
          fprintf(_coverage_fout, "5724\n");
          fflush(_coverage_fout);
          ___coverage_array[5724] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5715] == 0) {
            {
            fprintf(_coverage_fout, "5715\n");
            fflush(_coverage_fout);
            ___coverage_array[5715] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = _emalloc(sizeof(zval_gc_info ));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5716] == 0) {
            {
            fprintf(_coverage_fout, "5716\n");
            fflush(_coverage_fout);
            ___coverage_array[5716] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          offset = (zval *)tmp___1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5717] == 0) {
            {
            fprintf(_coverage_fout, "5717\n");
            fflush(_coverage_fout);
            ___coverage_array[5717] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          ((zval_gc_info *)offset)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5725] == 0) {
          {
          fprintf(_coverage_fout, "5725\n");
          fflush(_coverage_fout);
          ___coverage_array[5725] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5720] == 0) {
            {
            fprintf(_coverage_fout, "5720\n");
            fflush(_coverage_fout);
            ___coverage_array[5720] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5718] == 0) {
              {
              fprintf(_coverage_fout, "5718\n");
              fflush(_coverage_fout);
              ___coverage_array[5718] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            offset->value = original_var->value;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5719] == 0) {
              {
              fprintf(_coverage_fout, "5719\n");
              fflush(_coverage_fout);
              ___coverage_array[5719] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            offset->type = original_var->type;
            break;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5721] == 0) {
            {
            fprintf(_coverage_fout, "5721\n");
            fflush(_coverage_fout);
            ___coverage_array[5721] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_set_refcount_p(offset, 1U);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5722] == 0) {
            {
            fprintf(_coverage_fout, "5722\n");
            fflush(_coverage_fout);
            ___coverage_array[5722] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_unset_isref_p(offset);
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5726] == 0) {
          {
          fprintf(_coverage_fout, "5726\n");
          fflush(_coverage_fout);
          ___coverage_array[5726] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(offset);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5727] == 0) {
          {
          fprintf(_coverage_fout, "5727\n");
          fflush(_coverage_fout);
          ___coverage_array[5727] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_addref_p(offset);
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5737] == 0) {
      {
      fprintf(_coverage_fout, "5737\n");
      fflush(_coverage_fout);
      ___coverage_array[5737] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_call_method(& object, ce, (zend_function **)((void *)0), "offsetget",
                     (int )(sizeof("offsetget") - 1U), & retval, 1, offset,
                     (zval *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5738] == 0) {
      {
      fprintf(_coverage_fout, "5738\n");
      fflush(_coverage_fout);
      ___coverage_array[5738] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& offset);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5739] == 0) {
      {
      fprintf(_coverage_fout, "5739\n");
      fflush(_coverage_fout);
      ___coverage_array[5739] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = __builtin_expect((long )(! retval), 0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5740] == 0) {
      {
      fprintf(_coverage_fout, "5740\n");
      fflush(_coverage_fout);
      ___coverage_array[5740] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___4) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5732] == 0) {
        {
        fprintf(_coverage_fout, "5732\n");
        fflush(_coverage_fout);
        ___coverage_array[5732] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___3 = __builtin_expect((long )(! executor_globals.exception), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5733] == 0) {
        {
        fprintf(_coverage_fout, "5733\n");
        fflush(_coverage_fout);
        ___coverage_array[5733] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___3) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5730] == 0) {
          {
          fprintf(_coverage_fout, "5730\n");
          fflush(_coverage_fout);
          ___coverage_array[5730] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_error_noreturn(1,
                            "Undefined offset for object of type %s used as array",
                            ce->name);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5731] == 0) {
          {
          fprintf(_coverage_fout, "5731\n");
          fflush(_coverage_fout);
          ___coverage_array[5731] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5734] == 0) {
        {
        fprintf(_coverage_fout, "5734\n");
        fflush(_coverage_fout);
        ___coverage_array[5734] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((zval *)0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5735] == 0) {
        {
        fprintf(_coverage_fout, "5735\n");
        fflush(_coverage_fout);
        ___coverage_array[5735] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5741] == 0) {
      {
      fprintf(_coverage_fout, "5741\n");
      fflush(_coverage_fout);
      ___coverage_array[5741] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_delref_p(retval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5742] == 0) {
      {
      fprintf(_coverage_fout, "5742\n");
      fflush(_coverage_fout);
      ___coverage_array[5742] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (retval);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5743] == 0) {
      {
      fprintf(_coverage_fout, "5743\n");
      fflush(_coverage_fout);
      ___coverage_array[5743] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error_noreturn(1, "Cannot use object of type %s as array", ce->name);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5744] == 0) {
      {
      fprintf(_coverage_fout, "5744\n");
      fflush(_coverage_fout);
      ___coverage_array[5744] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((zval *)0);
  }
}
}
static void zend_std_write_dimension(zval *object , zval *offset , zval *value ) 
{ zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_bool tmp___2 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___3 ;
  long tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5774] == 0) {
    {
    fprintf(_coverage_fout, "5774\n");
    fflush(_coverage_fout);
    ___coverage_array[5774] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5775] == 0) {
    {
    fprintf(_coverage_fout, "5775\n");
    fflush(_coverage_fout);
    ___coverage_array[5775] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5776] == 0) {
    {
    fprintf(_coverage_fout, "5776\n");
    fflush(_coverage_fout);
    ___coverage_array[5776] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = instanceof_function_ex((zend_class_entry const   *)ce,
                                   (zend_class_entry const   *)zend_ce_arrayaccess,
                                   (unsigned char)1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5777] == 0) {
    {
    fprintf(_coverage_fout, "5777\n");
    fflush(_coverage_fout);
    ___coverage_array[5777] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((int __attribute__((__visibility__("default")))  )tmp___3 != (int __attribute__((__visibility__("default")))  )0),
                             1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5778] == 0) {
    {
    fprintf(_coverage_fout, "5778\n");
    fflush(_coverage_fout);
    ___coverage_array[5778] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5770] == 0) {
      {
      fprintf(_coverage_fout, "5770\n");
      fflush(_coverage_fout);
      ___coverage_array[5770] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! offset) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5753] == 0) {
        {
        fprintf(_coverage_fout, "5753\n");
        fflush(_coverage_fout);
        ___coverage_array[5753] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5750] == 0) {
          {
          fprintf(_coverage_fout, "5750\n");
          fflush(_coverage_fout);
          ___coverage_array[5750] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5751] == 0) {
          {
          fprintf(_coverage_fout, "5751\n");
          fflush(_coverage_fout);
          ___coverage_array[5751] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = (zval *)tmp___0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5752] == 0) {
          {
          fprintf(_coverage_fout, "5752\n");
          fflush(_coverage_fout);
          ___coverage_array[5752] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)offset)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5754] == 0) {
        {
        fprintf(_coverage_fout, "5754\n");
        fflush(_coverage_fout);
        ___coverage_array[5754] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *offset = (struct _zval_struct )zval_used_for_init;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5768] == 0) {
        {
        fprintf(_coverage_fout, "5768\n");
        fflush(_coverage_fout);
        ___coverage_array[5768] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = zval_isref_p(offset);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5769] == 0) {
        {
        fprintf(_coverage_fout, "5769\n");
        fflush(_coverage_fout);
        ___coverage_array[5769] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5763] == 0) {
          {
          fprintf(_coverage_fout, "5763\n");
          fflush(_coverage_fout);
          ___coverage_array[5763] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        original_var = offset;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5764] == 0) {
          {
          fprintf(_coverage_fout, "5764\n");
          fflush(_coverage_fout);
          ___coverage_array[5764] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5755] == 0) {
            {
            fprintf(_coverage_fout, "5755\n");
            fflush(_coverage_fout);
            ___coverage_array[5755] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = _emalloc(sizeof(zval_gc_info ));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5756] == 0) {
            {
            fprintf(_coverage_fout, "5756\n");
            fflush(_coverage_fout);
            ___coverage_array[5756] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          offset = (zval *)tmp___1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5757] == 0) {
            {
            fprintf(_coverage_fout, "5757\n");
            fflush(_coverage_fout);
            ___coverage_array[5757] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          ((zval_gc_info *)offset)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5765] == 0) {
          {
          fprintf(_coverage_fout, "5765\n");
          fflush(_coverage_fout);
          ___coverage_array[5765] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5760] == 0) {
            {
            fprintf(_coverage_fout, "5760\n");
            fflush(_coverage_fout);
            ___coverage_array[5760] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5758] == 0) {
              {
              fprintf(_coverage_fout, "5758\n");
              fflush(_coverage_fout);
              ___coverage_array[5758] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            offset->value = original_var->value;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5759] == 0) {
              {
              fprintf(_coverage_fout, "5759\n");
              fflush(_coverage_fout);
              ___coverage_array[5759] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            offset->type = original_var->type;
            break;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5761] == 0) {
            {
            fprintf(_coverage_fout, "5761\n");
            fflush(_coverage_fout);
            ___coverage_array[5761] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_set_refcount_p(offset, 1U);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5762] == 0) {
            {
            fprintf(_coverage_fout, "5762\n");
            fflush(_coverage_fout);
            ___coverage_array[5762] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_unset_isref_p(offset);
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5766] == 0) {
          {
          fprintf(_coverage_fout, "5766\n");
          fflush(_coverage_fout);
          ___coverage_array[5766] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(offset);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5767] == 0) {
          {
          fprintf(_coverage_fout, "5767\n");
          fflush(_coverage_fout);
          ___coverage_array[5767] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_addref_p(offset);
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5771] == 0) {
      {
      fprintf(_coverage_fout, "5771\n");
      fflush(_coverage_fout);
      ___coverage_array[5771] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_call_method(& object, ce, (zend_function **)((void *)0), "offsetset",
                     (int )(sizeof("offsetset") - 1U), (zval **)((void *)0), 2,
                     offset, value);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5772] == 0) {
      {
      fprintf(_coverage_fout, "5772\n");
      fflush(_coverage_fout);
      ___coverage_array[5772] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& offset);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5773] == 0) {
      {
      fprintf(_coverage_fout, "5773\n");
      fflush(_coverage_fout);
      ___coverage_array[5773] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error_noreturn(1, "Cannot use object of type %s as array", ce->name);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5779] == 0) {
    {
    fprintf(_coverage_fout, "5779\n");
    fflush(_coverage_fout);
    ___coverage_array[5779] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int zend_std_has_dimension(zval *object , zval *offset , int check_empty ) 
{ zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *retval ;
  int result ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_bool tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___4 ;
  long tmp___5 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5816] == 0) {
    {
    fprintf(_coverage_fout, "5816\n");
    fflush(_coverage_fout);
    ___coverage_array[5816] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5817] == 0) {
    {
    fprintf(_coverage_fout, "5817\n");
    fflush(_coverage_fout);
    ___coverage_array[5817] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5818] == 0) {
    {
    fprintf(_coverage_fout, "5818\n");
    fflush(_coverage_fout);
    ___coverage_array[5818] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = instanceof_function_ex((zend_class_entry const   *)ce,
                                   (zend_class_entry const   *)zend_ce_arrayaccess,
                                   (unsigned char)1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5819] == 0) {
    {
    fprintf(_coverage_fout, "5819\n");
    fflush(_coverage_fout);
    ___coverage_array[5819] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = __builtin_expect((long )((int __attribute__((__visibility__("default")))  )tmp___4 != (int __attribute__((__visibility__("default")))  )0),
                             1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5820] == 0) {
    {
    fprintf(_coverage_fout, "5820\n");
    fflush(_coverage_fout);
    ___coverage_array[5820] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___5) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5808] == 0) {
      {
      fprintf(_coverage_fout, "5808\n");
      fflush(_coverage_fout);
      ___coverage_array[5808] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = zval_isref_p(offset);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5809] == 0) {
      {
      fprintf(_coverage_fout, "5809\n");
      fflush(_coverage_fout);
      ___coverage_array[5809] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5788] == 0) {
        {
        fprintf(_coverage_fout, "5788\n");
        fflush(_coverage_fout);
        ___coverage_array[5788] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      original_var = offset;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5789] == 0) {
        {
        fprintf(_coverage_fout, "5789\n");
        fflush(_coverage_fout);
        ___coverage_array[5789] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5780] == 0) {
          {
          fprintf(_coverage_fout, "5780\n");
          fflush(_coverage_fout);
          ___coverage_array[5780] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5781] == 0) {
          {
          fprintf(_coverage_fout, "5781\n");
          fflush(_coverage_fout);
          ___coverage_array[5781] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = (zval *)tmp___0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5782] == 0) {
          {
          fprintf(_coverage_fout, "5782\n");
          fflush(_coverage_fout);
          ___coverage_array[5782] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)offset)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5790] == 0) {
        {
        fprintf(_coverage_fout, "5790\n");
        fflush(_coverage_fout);
        ___coverage_array[5790] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5785] == 0) {
          {
          fprintf(_coverage_fout, "5785\n");
          fflush(_coverage_fout);
          ___coverage_array[5785] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5783] == 0) {
            {
            fprintf(_coverage_fout, "5783\n");
            fflush(_coverage_fout);
            ___coverage_array[5783] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          offset->value = original_var->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5784] == 0) {
            {
            fprintf(_coverage_fout, "5784\n");
            fflush(_coverage_fout);
            ___coverage_array[5784] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          offset->type = original_var->type;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5786] == 0) {
          {
          fprintf(_coverage_fout, "5786\n");
          fflush(_coverage_fout);
          ___coverage_array[5786] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_refcount_p(offset, 1U);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5787] == 0) {
          {
          fprintf(_coverage_fout, "5787\n");
          fflush(_coverage_fout);
          ___coverage_array[5787] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_unset_isref_p(offset);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5791] == 0) {
        {
        fprintf(_coverage_fout, "5791\n");
        fflush(_coverage_fout);
        ___coverage_array[5791] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _zval_copy_ctor(offset);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5792] == 0) {
        {
        fprintf(_coverage_fout, "5792\n");
        fflush(_coverage_fout);
        ___coverage_array[5792] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_addref_p(offset);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5810] == 0) {
      {
      fprintf(_coverage_fout, "5810\n");
      fflush(_coverage_fout);
      ___coverage_array[5810] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_call_method(& object, ce, (zend_function **)((void *)0),
                     "offsetexists", (int )(sizeof("offsetexists") - 1U),
                     & retval, 1, offset, (zval *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5811] == 0) {
      {
      fprintf(_coverage_fout, "5811\n");
      fflush(_coverage_fout);
      ___coverage_array[5811] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = __builtin_expect((long )((unsigned int )retval != (unsigned int )((void *)0)),
                               1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5812] == 0) {
      {
      fprintf(_coverage_fout, "5812\n");
      fflush(_coverage_fout);
      ___coverage_array[5812] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5804] == 0) {
        {
        fprintf(_coverage_fout, "5804\n");
        fflush(_coverage_fout);
        ___coverage_array[5804] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = i_zend_is_true(retval);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5805] == 0) {
        {
        fprintf(_coverage_fout, "5805\n");
        fflush(_coverage_fout);
        ___coverage_array[5805] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _zval_ptr_dtor(& retval);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5806] == 0) {
        {
        fprintf(_coverage_fout, "5806\n");
        fflush(_coverage_fout);
        ___coverage_array[5806] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (check_empty) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5802] == 0) {
          {
          fprintf(_coverage_fout, "5802\n");
          fflush(_coverage_fout);
          ___coverage_array[5802] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (result) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5799] == 0) {
            {
            fprintf(_coverage_fout, "5799\n");
            fflush(_coverage_fout);
            ___coverage_array[5799] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___2 = __builtin_expect((long )(! executor_globals.exception), 1L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5800] == 0) {
            {
            fprintf(_coverage_fout, "5800\n");
            fflush(_coverage_fout);
            ___coverage_array[5800] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___2) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5796] == 0) {
              {
              fprintf(_coverage_fout, "5796\n");
              fflush(_coverage_fout);
              ___coverage_array[5796] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            zend_call_method(& object, ce, (zend_function **)((void *)0),
                             "offsetget", (int )(sizeof("offsetget") - 1U),
                             & retval, 1, offset, (zval *)((void *)0));
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5797] == 0) {
              {
              fprintf(_coverage_fout, "5797\n");
              fflush(_coverage_fout);
              ___coverage_array[5797] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (retval) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5793] == 0) {
                {
                fprintf(_coverage_fout, "5793\n");
                fflush(_coverage_fout);
                ___coverage_array[5793] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              result = i_zend_is_true(retval);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5794] == 0) {
                {
                fprintf(_coverage_fout, "5794\n");
                fflush(_coverage_fout);
                ___coverage_array[5794] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _zval_ptr_dtor(& retval);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5795] == 0) {
                {
                fprintf(_coverage_fout, "5795\n");
                fflush(_coverage_fout);
                ___coverage_array[5795] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5798] == 0) {
              {
              fprintf(_coverage_fout, "5798\n");
              fflush(_coverage_fout);
              ___coverage_array[5798] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5801] == 0) {
            {
            fprintf(_coverage_fout, "5801\n");
            fflush(_coverage_fout);
            ___coverage_array[5801] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5803] == 0) {
          {
          fprintf(_coverage_fout, "5803\n");
          fflush(_coverage_fout);
          ___coverage_array[5803] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5807] == 0) {
        {
        fprintf(_coverage_fout, "5807\n");
        fflush(_coverage_fout);
        ___coverage_array[5807] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5813] == 0) {
      {
      fprintf(_coverage_fout, "5813\n");
      fflush(_coverage_fout);
      ___coverage_array[5813] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& offset);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5814] == 0) {
      {
      fprintf(_coverage_fout, "5814\n");
      fflush(_coverage_fout);
      ___coverage_array[5814] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error_noreturn(1, "Cannot use object of type %s as array", ce->name);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5815] == 0) {
      {
      fprintf(_coverage_fout, "5815\n");
      fflush(_coverage_fout);
      ___coverage_array[5815] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (0);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5821] == 0) {
    {
    fprintf(_coverage_fout, "5821\n");
    fflush(_coverage_fout);
    ___coverage_array[5821] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result);
}
}
static zval **zend_std_get_property_ptr_ptr(zval *object , zval *member ,
                                            zend_literal const   *key ) 
{ zend_object *zobj ;
  zval tmp_member ;
  zval **retval ;
  zend_property_info *property_info ;
  long tmp ;
  zval *new_zval ;
  zend_guard *guard ;
  long tmp___0 ;
  int tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  int tmp___4 ;
  long tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;
  long tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  long tmp___10 ;
  long tmp___11 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5876] == 0) {
    {
    fprintf(_coverage_fout, "5876\n");
    fflush(_coverage_fout);
    ___coverage_array[5876] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5877] == 0) {
    {
    fprintf(_coverage_fout, "5877\n");
    fflush(_coverage_fout);
    ___coverage_array[5877] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_expect((long )((int )member->type != 6), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5878] == 0) {
    {
    fprintf(_coverage_fout, "5878\n");
    fflush(_coverage_fout);
    ___coverage_array[5878] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5824] == 0) {
      {
      fprintf(_coverage_fout, "5824\n");
      fflush(_coverage_fout);
      ___coverage_array[5824] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5825] == 0) {
      {
      fprintf(_coverage_fout, "5825\n");
      fflush(_coverage_fout);
      ___coverage_array[5825] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(& tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5826] == 0) {
      {
      fprintf(_coverage_fout, "5826\n");
      fflush(_coverage_fout);
      ___coverage_array[5826] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )tmp_member.type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5822] == 0) {
        {
        fprintf(_coverage_fout, "5822\n");
        fflush(_coverage_fout);
        ___coverage_array[5822] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(& tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5823] == 0) {
        {
        fprintf(_coverage_fout, "5823\n");
        fflush(_coverage_fout);
        ___coverage_array[5823] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5827] == 0) {
      {
      fprintf(_coverage_fout, "5827\n");
      fflush(_coverage_fout);
      ___coverage_array[5827] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = & tmp_member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5828] == 0) {
      {
      fprintf(_coverage_fout, "5828\n");
      fflush(_coverage_fout);
      ___coverage_array[5828] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    key = (zend_literal const   *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5829] == 0) {
      {
      fprintf(_coverage_fout, "5829\n");
      fflush(_coverage_fout);
      ___coverage_array[5829] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5879] == 0) {
    {
    fprintf(_coverage_fout, "5879\n");
    fflush(_coverage_fout);
    ___coverage_array[5879] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = zend_get_property_info_quick(zobj->ce, member,
                                               (unsigned int )(zobj->ce)->__get != (unsigned int )((void *)0),
                                               key);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5880] == 0) {
    {
    fprintf(_coverage_fout, "5880\n");
    fflush(_coverage_fout);
    ___coverage_array[5880] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = __builtin_expect((long )(! property_info), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5881] == 0) {
    {
    fprintf(_coverage_fout, "5881\n");
    fflush(_coverage_fout);
    ___coverage_array[5881] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    goto _L___2;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5871] == 0) {
      {
      fprintf(_coverage_fout, "5871\n");
      fflush(_coverage_fout);
      ___coverage_array[5871] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = __builtin_expect((long )((property_info->flags & 1U) == 0U), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5872] == 0) {
      {
      fprintf(_coverage_fout, "5872\n");
      fflush(_coverage_fout);
      ___coverage_array[5872] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___10) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5836] == 0) {
        {
        fprintf(_coverage_fout, "5836\n");
        fflush(_coverage_fout);
        ___coverage_array[5836] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (property_info->offset >= 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5834] == 0) {
          {
          fprintf(_coverage_fout, "5834\n");
          fflush(_coverage_fout);
          ___coverage_array[5834] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (zobj->properties) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5830] == 0) {
            {
            fprintf(_coverage_fout, "5830\n");
            fflush(_coverage_fout);
            ___coverage_array[5830] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          retval = (zval **)*(zobj->properties_table + property_info->offset);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5831] == 0) {
            {
            fprintf(_coverage_fout, "5831\n");
            fflush(_coverage_fout);
            ___coverage_array[5831] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___4 = (unsigned int )retval == (unsigned int )((void *)0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5832] == 0) {
            {
            fprintf(_coverage_fout, "5832\n");
            fflush(_coverage_fout);
            ___coverage_array[5832] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          retval = zobj->properties_table + property_info->offset;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5833] == 0) {
            {
            fprintf(_coverage_fout, "5833\n");
            fflush(_coverage_fout);
            ___coverage_array[5833] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___4 = (unsigned int )*retval == (unsigned int )((void *)0);
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5835] == 0) {
          {
          fprintf(_coverage_fout, "5835\n");
          fflush(_coverage_fout);
          ___coverage_array[5835] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___9 = tmp___4;
      } else {
        goto _L___1;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5843] == 0) {
        {
        fprintf(_coverage_fout, "5843\n");
        fflush(_coverage_fout);
        ___coverage_array[5843] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___1: /* CIL Label */ 
      tmp___5 = __builtin_expect((long )(! zobj->properties), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5844] == 0) {
        {
        fprintf(_coverage_fout, "5844\n");
        fflush(_coverage_fout);
        ___coverage_array[5844] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___5) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5837] == 0) {
          {
          fprintf(_coverage_fout, "5837\n");
          fflush(_coverage_fout);
          ___coverage_array[5837] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = 1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5840] == 0) {
          {
          fprintf(_coverage_fout, "5840\n");
          fflush(_coverage_fout);
          ___coverage_array[5840] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___6 = zend_hash_quick_find((HashTable const   *)zobj->properties,
                                       property_info->name,
                                       (unsigned int )(property_info->name_length + 1),
                                       property_info->h, (void **)(& retval));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5841] == 0) {
          {
          fprintf(_coverage_fout, "5841\n");
          fflush(_coverage_fout);
          ___coverage_array[5841] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___7 = __builtin_expect((long )(tmp___6 == (int __attribute__((__visibility__("default")))  )-1),
                                   0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5842] == 0) {
          {
          fprintf(_coverage_fout, "5842\n");
          fflush(_coverage_fout);
          ___coverage_array[5842] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___7) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5838] == 0) {
            {
            fprintf(_coverage_fout, "5838\n");
            fflush(_coverage_fout);
            ___coverage_array[5838] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = 1;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5839] == 0) {
            {
            fprintf(_coverage_fout, "5839\n");
            fflush(_coverage_fout);
            ___coverage_array[5839] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5845] == 0) {
        {
        fprintf(_coverage_fout, "5845\n");
        fflush(_coverage_fout);
        ___coverage_array[5845] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___9 = tmp___8;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5873] == 0) {
      {
      fprintf(_coverage_fout, "5873\n");
      fflush(_coverage_fout);
      ___coverage_array[5873] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___9) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5869] == 0) {
        {
        fprintf(_coverage_fout, "5869\n");
        fflush(_coverage_fout);
        ___coverage_array[5869] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___2: /* CIL Label */ 
      if (! (zobj->ce)->__get) {
        goto _L___0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5867] == 0) {
          {
          fprintf(_coverage_fout, "5867\n");
          fflush(_coverage_fout);
          ___coverage_array[5867] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = zend_get_property_guard(zobj, property_info, member, & guard);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5868] == 0) {
          {
          fprintf(_coverage_fout, "5868\n");
          fflush(_coverage_fout);
          ___coverage_array[5868] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1 != 0) {
          goto _L___0;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5866] == 0) {
            {
            fprintf(_coverage_fout, "5866\n");
            fflush(_coverage_fout);
            ___coverage_array[5866] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (property_info) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5864] == 0) {
              {
              fprintf(_coverage_fout, "5864\n");
              fflush(_coverage_fout);
              ___coverage_array[5864] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (guard->in_get) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5859] == 0) {
                {
                fprintf(_coverage_fout, "5859\n");
                fflush(_coverage_fout);
                ___coverage_array[5859] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _L___0: /* CIL Label */ 
              new_zval = & executor_globals.uninitialized_zval;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5860] == 0) {
                {
                fprintf(_coverage_fout, "5860\n");
                fflush(_coverage_fout);
                ___coverage_array[5860] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zval_addref_p(new_zval);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5861] == 0) {
                {
                fprintf(_coverage_fout, "5861\n");
                fflush(_coverage_fout);
                ___coverage_array[5861] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___0 = __builtin_expect((long )((property_info->flags & 1U) == 0U),
                                         1L);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5862] == 0) {
                {
                fprintf(_coverage_fout, "5862\n");
                fflush(_coverage_fout);
                ___coverage_array[5862] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (tmp___0) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5854] == 0) {
                  {
                  fprintf(_coverage_fout, "5854\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5854] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (property_info->offset >= 0) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5853] == 0) {
                    {
                    fprintf(_coverage_fout, "5853\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5853] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if (! zobj->properties) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5846] == 0) {
                      {
                      fprintf(_coverage_fout, "5846\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5846] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    *(zobj->properties_table + property_info->offset) = new_zval;
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5847] == 0) {
                      {
                      fprintf(_coverage_fout, "5847\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5847] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    retval = zobj->properties_table + property_info->offset;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5852] == 0) {
                      {
                      fprintf(_coverage_fout, "5852\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5852] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    if (*(zobj->properties_table + property_info->offset)) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5848] == 0) {
                        {
                        fprintf(_coverage_fout, "5848\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5848] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      *((zval **)*(zobj->properties_table + property_info->offset)) = new_zval;
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5849] == 0) {
                        {
                        fprintf(_coverage_fout, "5849\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5849] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      retval = (zval **)*(zobj->properties_table + property_info->offset);
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5850] == 0) {
                        {
                        fprintf(_coverage_fout, "5850\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5850] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      _zend_hash_quick_add_or_update(zobj->properties,
                                                     property_info->name,
                                                     (unsigned int )(property_info->name_length + 1),
                                                     property_info->h,
                                                     (void *)(& new_zval),
                                                     sizeof(zval *),
                                                     (void **)(zobj->properties_table + property_info->offset),
                                                     1);
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5851] == 0) {
                        {
                        fprintf(_coverage_fout, "5851\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5851] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      retval = (zval **)*(zobj->properties_table + property_info->offset);
                    }
                  }
                } else {
                  goto _L;
                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5857] == 0) {
                  {
                  fprintf(_coverage_fout, "5857\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5857] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _L: /* CIL Label */ 
                if (! zobj->properties) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5855] == 0) {
                    {
                    fprintf(_coverage_fout, "5855\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5855] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  rebuild_object_properties(zobj);
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5856] == 0) {
                    {
                    fprintf(_coverage_fout, "5856\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5856] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5858] == 0) {
                  {
                  fprintf(_coverage_fout, "5858\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5858] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _zend_hash_quick_add_or_update(zobj->properties,
                                               property_info->name,
                                               (unsigned int )(property_info->name_length + 1),
                                               property_info->h,
                                               (void *)(& new_zval),
                                               sizeof(zval *),
                                               (void **)(& retval), 1);
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5863] == 0) {
                {
                fprintf(_coverage_fout, "5863\n");
                fflush(_coverage_fout);
                ___coverage_array[5863] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              retval = (zval **)((void *)0);
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5865] == 0) {
              {
              fprintf(_coverage_fout, "5865\n");
              fflush(_coverage_fout);
              ___coverage_array[5865] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            retval = (zval **)((void *)0);
          }
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5870] == 0) {
        {
        fprintf(_coverage_fout, "5870\n");
        fflush(_coverage_fout);
        ___coverage_array[5870] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5882] == 0) {
    {
    fprintf(_coverage_fout, "5882\n");
    fflush(_coverage_fout);
    ___coverage_array[5882] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___11 = __builtin_expect((long )((unsigned int )member == (unsigned int )(& tmp_member)),
                              0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5883] == 0) {
    {
    fprintf(_coverage_fout, "5883\n");
    fflush(_coverage_fout);
    ___coverage_array[5883] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___11) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5874] == 0) {
      {
      fprintf(_coverage_fout, "5874\n");
      fflush(_coverage_fout);
      ___coverage_array[5874] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5875] == 0) {
      {
      fprintf(_coverage_fout, "5875\n");
      fflush(_coverage_fout);
      ___coverage_array[5875] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5884] == 0) {
    {
    fprintf(_coverage_fout, "5884\n");
    fflush(_coverage_fout);
    ___coverage_array[5884] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
static void zend_std_unset_property(zval *object , zval *member ,
                                    zend_literal const   *key ) 
{ zend_object *zobj ;
  zval *tmp_member ;
  zend_property_info *property_info ;
  void __attribute__((__visibility__("default")))  *tmp ;
  long tmp___0 ;
  zend_guard *guard ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_uint tmp___2 ;
  zend_bool tmp___3 ;
  int tmp___4 ;
  long tmp___5 ;
  long tmp___6 ;
  long tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;
  long tmp___9 ;
  long tmp___10 ;
  long tmp___11 ;
  long tmp___12 ;
  long tmp___13 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5965] == 0) {
    {
    fprintf(_coverage_fout, "5965\n");
    fflush(_coverage_fout);
    ___coverage_array[5965] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp_member = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5966] == 0) {
    {
    fprintf(_coverage_fout, "5966\n");
    fflush(_coverage_fout);
    ___coverage_array[5966] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5967] == 0) {
    {
    fprintf(_coverage_fout, "5967\n");
    fflush(_coverage_fout);
    ___coverage_array[5967] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = __builtin_expect((long )((int )member->type != 6), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5968] == 0) {
    {
    fprintf(_coverage_fout, "5968\n");
    fflush(_coverage_fout);
    ___coverage_array[5968] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5890] == 0) {
      {
      fprintf(_coverage_fout, "5890\n");
      fflush(_coverage_fout);
      ___coverage_array[5890] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5885] == 0) {
        {
        fprintf(_coverage_fout, "5885\n");
        fflush(_coverage_fout);
        ___coverage_array[5885] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5886] == 0) {
        {
        fprintf(_coverage_fout, "5886\n");
        fflush(_coverage_fout);
        ___coverage_array[5886] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp_member = (zval *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5887] == 0) {
        {
        fprintf(_coverage_fout, "5887\n");
        fflush(_coverage_fout);
        ___coverage_array[5887] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)tmp_member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5891] == 0) {
      {
      fprintf(_coverage_fout, "5891\n");
      fflush(_coverage_fout);
      ___coverage_array[5891] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5892] == 0) {
      {
      fprintf(_coverage_fout, "5892\n");
      fflush(_coverage_fout);
      ___coverage_array[5892] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5893] == 0) {
      {
      fprintf(_coverage_fout, "5893\n");
      fflush(_coverage_fout);
      ___coverage_array[5893] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5894] == 0) {
      {
      fprintf(_coverage_fout, "5894\n");
      fflush(_coverage_fout);
      ___coverage_array[5894] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5895] == 0) {
      {
      fprintf(_coverage_fout, "5895\n");
      fflush(_coverage_fout);
      ___coverage_array[5895] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )tmp_member->type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5888] == 0) {
        {
        fprintf(_coverage_fout, "5888\n");
        fflush(_coverage_fout);
        ___coverage_array[5888] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5889] == 0) {
        {
        fprintf(_coverage_fout, "5889\n");
        fflush(_coverage_fout);
        ___coverage_array[5889] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5896] == 0) {
      {
      fprintf(_coverage_fout, "5896\n");
      fflush(_coverage_fout);
      ___coverage_array[5896] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = tmp_member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5897] == 0) {
      {
      fprintf(_coverage_fout, "5897\n");
      fflush(_coverage_fout);
      ___coverage_array[5897] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    key = (zend_literal const   *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5898] == 0) {
      {
      fprintf(_coverage_fout, "5898\n");
      fflush(_coverage_fout);
      ___coverage_array[5898] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5969] == 0) {
    {
    fprintf(_coverage_fout, "5969\n");
    fflush(_coverage_fout);
    ___coverage_array[5969] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = zend_get_property_info_quick(zobj->ce, member,
                                               (unsigned int )(zobj->ce)->__unset != (unsigned int )((void *)0),
                                               key);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5970] == 0) {
    {
    fprintf(_coverage_fout, "5970\n");
    fflush(_coverage_fout);
    ___coverage_array[5970] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___10 = __builtin_expect((long )((unsigned int )property_info != (unsigned int )((void *)0)),
                              1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5971] == 0) {
    {
    fprintf(_coverage_fout, "5971\n");
    fflush(_coverage_fout);
    ___coverage_array[5971] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___10) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5905] == 0) {
      {
      fprintf(_coverage_fout, "5905\n");
      fflush(_coverage_fout);
      ___coverage_array[5905] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___11 = __builtin_expect((long )((property_info->flags & 1U) == 0U), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5906] == 0) {
      {
      fprintf(_coverage_fout, "5906\n");
      fflush(_coverage_fout);
      ___coverage_array[5906] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___11) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5904] == 0) {
        {
        fprintf(_coverage_fout, "5904\n");
        fflush(_coverage_fout);
        ___coverage_array[5904] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! zobj->properties) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5903] == 0) {
          {
          fprintf(_coverage_fout, "5903\n");
          fflush(_coverage_fout);
          ___coverage_array[5903] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (property_info->offset >= 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5901] == 0) {
            {
            fprintf(_coverage_fout, "5901\n");
            fflush(_coverage_fout);
            ___coverage_array[5901] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___12 = __builtin_expect((long )((unsigned int )*(zobj->properties_table + property_info->offset) != (unsigned int )((void *)0)),
                                      1L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5902] == 0) {
            {
            fprintf(_coverage_fout, "5902\n");
            fflush(_coverage_fout);
            ___coverage_array[5902] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___12) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5899] == 0) {
              {
              fprintf(_coverage_fout, "5899\n");
              fflush(_coverage_fout);
              ___coverage_array[5899] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_ptr_dtor(zobj->properties_table + property_info->offset);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5900] == 0) {
              {
              fprintf(_coverage_fout, "5900\n");
              fflush(_coverage_fout);
              ___coverage_array[5900] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *(zobj->properties_table + property_info->offset) = (zval *)((void *)0);
          } else {
            goto _L___5;
          }
        } else {
          goto _L___5;
        }
      } else {
        goto _L___5;
      }
    } else {
      goto _L___5;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5961] == 0) {
      {
      fprintf(_coverage_fout, "5961\n");
      fflush(_coverage_fout);
      ___coverage_array[5961] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L___5: /* CIL Label */ 
    _L___4: /* CIL Label */ 
    _L___3: /* CIL Label */ 
    _L___2: /* CIL Label */ 
    tmp___7 = __builtin_expect((long )(! property_info), 0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5962] == 0) {
      {
      fprintf(_coverage_fout, "5962\n");
      fflush(_coverage_fout);
      ___coverage_array[5962] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___7) {
      goto _L___1;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5960] == 0) {
        {
        fprintf(_coverage_fout, "5960\n");
        fflush(_coverage_fout);
        ___coverage_array[5960] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! zobj->properties) {
        goto _L___1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5957] == 0) {
          {
          fprintf(_coverage_fout, "5957\n");
          fflush(_coverage_fout);
          ___coverage_array[5957] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = zend_hash_del_key_or_index(zobj->properties,
                                             property_info->name,
                                             (unsigned int )(property_info->name_length + 1),
                                             property_info->h, 2);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5958] == 0) {
          {
          fprintf(_coverage_fout, "5958\n");
          fflush(_coverage_fout);
          ___coverage_array[5958] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___9 = __builtin_expect((long )(tmp___8 == (int __attribute__((__visibility__("default")))  )-1),
                                   0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5959] == 0) {
          {
          fprintf(_coverage_fout, "5959\n");
          fflush(_coverage_fout);
          ___coverage_array[5959] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___9) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5946] == 0) {
            {
            fprintf(_coverage_fout, "5946\n");
            fflush(_coverage_fout);
            ___coverage_array[5946] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___1: /* CIL Label */ 
          guard = (zend_guard *)((void *)0);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5947] == 0) {
            {
            fprintf(_coverage_fout, "5947\n");
            fflush(_coverage_fout);
            ___coverage_array[5947] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((zobj->ce)->__unset) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5933] == 0) {
              {
              fprintf(_coverage_fout, "5933\n");
              fflush(_coverage_fout);
              ___coverage_array[5933] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___4 = zend_get_property_guard(zobj, property_info, member,
                                              & guard);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5934] == 0) {
              {
              fprintf(_coverage_fout, "5934\n");
              fflush(_coverage_fout);
              ___coverage_array[5934] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp___4 == 0) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5932] == 0) {
                {
                fprintf(_coverage_fout, "5932\n");
                fflush(_coverage_fout);
                ___coverage_array[5932] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (! guard->in_unset) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5925] == 0) {
                  {
                  fprintf(_coverage_fout, "5925\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5925] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                zval_addref_p(object);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5926] == 0) {
                  {
                  fprintf(_coverage_fout, "5926\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5926] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___3 = zval_isref_p(object);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5927] == 0) {
                  {
                  fprintf(_coverage_fout, "5927\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5927] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (tmp___3) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5923] == 0) {
                    {
                    fprintf(_coverage_fout, "5923\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5923] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  while (1) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5921] == 0) {
                      {
                      fprintf(_coverage_fout, "5921\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5921] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    tmp___2 = zval_refcount_p(object);
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5922] == 0) {
                      {
                      fprintf(_coverage_fout, "5922\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5922] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    if (tmp___2 > 1U) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5915] == 0) {
                        {
                        fprintf(_coverage_fout, "5915\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5915] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      zval_delref_p(object);
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5916] == 0) {
                        {
                        fprintf(_coverage_fout, "5916\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5916] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      while (1) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5907] == 0) {
                          {
                          fprintf(_coverage_fout, "5907\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5907] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        tmp___1 = _emalloc(sizeof(zval_gc_info ));
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5908] == 0) {
                          {
                          fprintf(_coverage_fout, "5908\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5908] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        new_zv = (zval *)tmp___1;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5909] == 0) {
                          {
                          fprintf(_coverage_fout, "5909\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5909] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
                        break;
                      }
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5917] == 0) {
                        {
                        fprintf(_coverage_fout, "5917\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5917] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      while (1) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5912] == 0) {
                          {
                          fprintf(_coverage_fout, "5912\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5912] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        while (1) {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[5910] == 0) {
                            {
                            fprintf(_coverage_fout, "5910\n");
                            fflush(_coverage_fout);
                            ___coverage_array[5910] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          new_zv->value = object->value;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[5911] == 0) {
                            {
                            fprintf(_coverage_fout, "5911\n");
                            fflush(_coverage_fout);
                            ___coverage_array[5911] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          new_zv->type = object->type;
                          break;
                        }
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5913] == 0) {
                          {
                          fprintf(_coverage_fout, "5913\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5913] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        zval_set_refcount_p(new_zv, 1U);
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[5914] == 0) {
                          {
                          fprintf(_coverage_fout, "5914\n");
                          fflush(_coverage_fout);
                          ___coverage_array[5914] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        zval_unset_isref_p(new_zv);
                        break;
                      }
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5918] == 0) {
                        {
                        fprintf(_coverage_fout, "5918\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5918] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      object = new_zv;
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5919] == 0) {
                        {
                        fprintf(_coverage_fout, "5919\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5919] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      _zval_copy_ctor(new_zv);
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5920] == 0) {
                        {
                        fprintf(_coverage_fout, "5920\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5920] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }

                    }
                    break;
                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5924] == 0) {
                    {
                    fprintf(_coverage_fout, "5924\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5924] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5928] == 0) {
                  {
                  fprintf(_coverage_fout, "5928\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5928] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                guard->in_unset = (unsigned char)1;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5929] == 0) {
                  {
                  fprintf(_coverage_fout, "5929\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5929] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                zend_std_call_unsetter(object, member);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5930] == 0) {
                  {
                  fprintf(_coverage_fout, "5930\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5930] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                guard->in_unset = (unsigned char)0;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5931] == 0) {
                  {
                  fprintf(_coverage_fout, "5931\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5931] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _zval_ptr_dtor(& object);
              } else {
                goto _L___0;
              }
            } else {
              goto _L___0;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5945] == 0) {
              {
              fprintf(_coverage_fout, "5945\n");
              fflush(_coverage_fout);
              ___coverage_array[5945] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _L___0: /* CIL Label */ 
            _L: /* CIL Label */ 
            if ((zobj->ce)->__unset) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5943] == 0) {
                {
                fprintf(_coverage_fout, "5943\n");
                fflush(_coverage_fout);
                ___coverage_array[5943] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (guard) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5941] == 0) {
                  {
                  fprintf(_coverage_fout, "5941\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5941] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int )guard->in_unset == 1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5939] == 0) {
                    {
                    fprintf(_coverage_fout, "5939\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5939] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int )*(member->value.str.val + 0) == 0) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5937] == 0) {
                      {
                      fprintf(_coverage_fout, "5937\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5937] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    if (member->value.str.len == 0) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5935] == 0) {
                        {
                        fprintf(_coverage_fout, "5935\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5935] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      zend_error(1, "Cannot access empty property");
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[5936] == 0) {
                        {
                        fprintf(_coverage_fout, "5936\n");
                        fflush(_coverage_fout);
                        ___coverage_array[5936] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      zend_error(1,
                                 "Cannot access property started with \'\\0\'");
                    }
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[5938] == 0) {
                      {
                      fprintf(_coverage_fout, "5938\n");
                      fflush(_coverage_fout);
                      ___coverage_array[5938] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[5940] == 0) {
                    {
                    fprintf(_coverage_fout, "5940\n");
                    fflush(_coverage_fout);
                    ___coverage_array[5940] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5942] == 0) {
                  {
                  fprintf(_coverage_fout, "5942\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5942] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5944] == 0) {
                {
                fprintf(_coverage_fout, "5944\n");
                fflush(_coverage_fout);
                ___coverage_array[5944] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5955] == 0) {
            {
            fprintf(_coverage_fout, "5955\n");
            fflush(_coverage_fout);
            ___coverage_array[5955] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___5 = __builtin_expect((long )((unsigned int )property_info != (unsigned int )((void *)0)),
                                     1L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5956] == 0) {
            {
            fprintf(_coverage_fout, "5956\n");
            fflush(_coverage_fout);
            ___coverage_array[5956] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___5) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5952] == 0) {
              {
              fprintf(_coverage_fout, "5952\n");
              fflush(_coverage_fout);
              ___coverage_array[5952] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___6 = __builtin_expect((long )((property_info->flags & 1U) == 0U),
                                       1L);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5953] == 0) {
              {
              fprintf(_coverage_fout, "5953\n");
              fflush(_coverage_fout);
              ___coverage_array[5953] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp___6) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5950] == 0) {
                {
                fprintf(_coverage_fout, "5950\n");
                fflush(_coverage_fout);
                ___coverage_array[5950] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (property_info->offset >= 0) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5948] == 0) {
                  {
                  fprintf(_coverage_fout, "5948\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5948] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                *(zobj->properties_table + property_info->offset) = (zval *)((void *)0);
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[5949] == 0) {
                  {
                  fprintf(_coverage_fout, "5949\n");
                  fflush(_coverage_fout);
                  ___coverage_array[5949] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[5951] == 0) {
                {
                fprintf(_coverage_fout, "5951\n");
                fflush(_coverage_fout);
                ___coverage_array[5951] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[5954] == 0) {
              {
              fprintf(_coverage_fout, "5954\n");
              fflush(_coverage_fout);
              ___coverage_array[5954] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        }
      }
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5972] == 0) {
    {
    fprintf(_coverage_fout, "5972\n");
    fflush(_coverage_fout);
    ___coverage_array[5972] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___13 = __builtin_expect((long )((unsigned int )tmp_member != (unsigned int )((void *)0)),
                              0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5973] == 0) {
    {
    fprintf(_coverage_fout, "5973\n");
    fflush(_coverage_fout);
    ___coverage_array[5973] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___13) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5963] == 0) {
      {
      fprintf(_coverage_fout, "5963\n");
      fflush(_coverage_fout);
      ___coverage_array[5963] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& tmp_member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5964] == 0) {
      {
      fprintf(_coverage_fout, "5964\n");
      fflush(_coverage_fout);
      ___coverage_array[5964] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5974] == 0) {
    {
    fprintf(_coverage_fout, "5974\n");
    fflush(_coverage_fout);
    ___coverage_array[5974] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void zend_std_unset_dimension(zval *object , zval *offset ) 
{ zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  zval *original_var ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_bool tmp___1 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5993] == 0) {
    {
    fprintf(_coverage_fout, "5993\n");
    fflush(_coverage_fout);
    ___coverage_array[5993] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5994] == 0) {
    {
    fprintf(_coverage_fout, "5994\n");
    fflush(_coverage_fout);
    ___coverage_array[5994] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5995] == 0) {
    {
    fprintf(_coverage_fout, "5995\n");
    fflush(_coverage_fout);
    ___coverage_array[5995] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = instanceof_function_ex((zend_class_entry const   *)ce,
                                   (zend_class_entry const   *)zend_ce_arrayaccess,
                                   (unsigned char)1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5996] == 0) {
    {
    fprintf(_coverage_fout, "5996\n");
    fflush(_coverage_fout);
    ___coverage_array[5996] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5988] == 0) {
      {
      fprintf(_coverage_fout, "5988\n");
      fflush(_coverage_fout);
      ___coverage_array[5988] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = zval_isref_p(offset);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5989] == 0) {
      {
      fprintf(_coverage_fout, "5989\n");
      fflush(_coverage_fout);
      ___coverage_array[5989] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5983] == 0) {
        {
        fprintf(_coverage_fout, "5983\n");
        fflush(_coverage_fout);
        ___coverage_array[5983] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      original_var = offset;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5984] == 0) {
        {
        fprintf(_coverage_fout, "5984\n");
        fflush(_coverage_fout);
        ___coverage_array[5984] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5975] == 0) {
          {
          fprintf(_coverage_fout, "5975\n");
          fflush(_coverage_fout);
          ___coverage_array[5975] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5976] == 0) {
          {
          fprintf(_coverage_fout, "5976\n");
          fflush(_coverage_fout);
          ___coverage_array[5976] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = (zval *)tmp___0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5977] == 0) {
          {
          fprintf(_coverage_fout, "5977\n");
          fflush(_coverage_fout);
          ___coverage_array[5977] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)offset)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5985] == 0) {
        {
        fprintf(_coverage_fout, "5985\n");
        fflush(_coverage_fout);
        ___coverage_array[5985] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5980] == 0) {
          {
          fprintf(_coverage_fout, "5980\n");
          fflush(_coverage_fout);
          ___coverage_array[5980] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5978] == 0) {
            {
            fprintf(_coverage_fout, "5978\n");
            fflush(_coverage_fout);
            ___coverage_array[5978] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          offset->value = original_var->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5979] == 0) {
            {
            fprintf(_coverage_fout, "5979\n");
            fflush(_coverage_fout);
            ___coverage_array[5979] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          offset->type = original_var->type;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5981] == 0) {
          {
          fprintf(_coverage_fout, "5981\n");
          fflush(_coverage_fout);
          ___coverage_array[5981] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_refcount_p(offset, 1U);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[5982] == 0) {
          {
          fprintf(_coverage_fout, "5982\n");
          fflush(_coverage_fout);
          ___coverage_array[5982] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_unset_isref_p(offset);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5986] == 0) {
        {
        fprintf(_coverage_fout, "5986\n");
        fflush(_coverage_fout);
        ___coverage_array[5986] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _zval_copy_ctor(offset);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[5987] == 0) {
        {
        fprintf(_coverage_fout, "5987\n");
        fflush(_coverage_fout);
        ___coverage_array[5987] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_addref_p(offset);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5990] == 0) {
      {
      fprintf(_coverage_fout, "5990\n");
      fflush(_coverage_fout);
      ___coverage_array[5990] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_call_method(& object, ce, (zend_function **)((void *)0), "offsetunset",
                     (int )(sizeof("offsetunset") - 1U), (zval **)((void *)0),
                     1, offset, (zval *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5991] == 0) {
      {
      fprintf(_coverage_fout, "5991\n");
      fflush(_coverage_fout);
      ___coverage_array[5991] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& offset);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5992] == 0) {
      {
      fprintf(_coverage_fout, "5992\n");
      fflush(_coverage_fout);
      ___coverage_array[5992] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error_noreturn(1, "Cannot use object of type %s as array", ce->name);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[5997] == 0) {
    {
    fprintf(_coverage_fout, "5997\n");
    fflush(_coverage_fout);
    ___coverage_array[5997] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
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 ) 
{ zend_internal_function *func ;
  zval *method_name_ptr ;
  zval *method_args_ptr ;
  zval *method_result_ptr ;
  zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  long tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___4 ;
  char __attribute__((__visibility__("default")))  *tmp___5 ;
  zend_uchar is_ref ;
  zend_bool tmp___6 ;
  zend_uint refcount ;
  zend_uint tmp___7 ;
  zend_uchar is_ref___0 ;
  zend_bool tmp___8 ;
  zend_uint refcount___0 ;
  zend_uint tmp___9 ;
  zend_bool tmp___10 ;
  zend_uint tmp___11 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6045] == 0) {
    {
    fprintf(_coverage_fout, "6045\n");
    fflush(_coverage_fout);
    ___coverage_array[6045] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  func = (zend_internal_function *)(executor_globals.current_execute_data)->function_state.function;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6046] == 0) {
    {
    fprintf(_coverage_fout, "6046\n");
    fflush(_coverage_fout);
    ___coverage_array[6046] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_result_ptr = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6047] == 0) {
    {
    fprintf(_coverage_fout, "6047\n");
    fflush(_coverage_fout);
    ___coverage_array[6047] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)this_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6048] == 0) {
    {
    fprintf(_coverage_fout, "6048\n");
    fflush(_coverage_fout);
    ___coverage_array[6048] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6049] == 0) {
    {
    fprintf(_coverage_fout, "6049\n");
    fflush(_coverage_fout);
    ___coverage_array[6049] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5998] == 0) {
      {
      fprintf(_coverage_fout, "5998\n");
      fflush(_coverage_fout);
      ___coverage_array[5998] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[5999] == 0) {
      {
      fprintf(_coverage_fout, "5999\n");
      fflush(_coverage_fout);
      ___coverage_array[5999] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    method_args_ptr = (zval *)tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6000] == 0) {
      {
      fprintf(_coverage_fout, "6000\n");
      fflush(_coverage_fout);
      ___coverage_array[6000] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)method_args_ptr)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6050] == 0) {
    {
    fprintf(_coverage_fout, "6050\n");
    fflush(_coverage_fout);
    ___coverage_array[6050] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_args_ptr->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6051] == 0) {
    {
    fprintf(_coverage_fout, "6051\n");
    fflush(_coverage_fout);
    ___coverage_array[6051] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_args_ptr->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6052] == 0) {
    {
    fprintf(_coverage_fout, "6052\n");
    fflush(_coverage_fout);
    ___coverage_array[6052] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(method_args_ptr, (unsigned int )ht);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6053] == 0) {
    {
    fprintf(_coverage_fout, "6053\n");
    fflush(_coverage_fout);
    ___coverage_array[6053] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_copy_parameters_array(ht, method_args_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6054] == 0) {
    {
    fprintf(_coverage_fout, "6054\n");
    fflush(_coverage_fout);
    ___coverage_array[6054] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = __builtin_expect((long )(tmp___1 == (int __attribute__((__visibility__("default")))  )-1),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6055] == 0) {
    {
    fprintf(_coverage_fout, "6055\n");
    fflush(_coverage_fout);
    ___coverage_array[6055] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6004] == 0) {
      {
      fprintf(_coverage_fout, "6004\n");
      fflush(_coverage_fout);
      ___coverage_array[6004] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(method_args_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6005] == 0) {
      {
      fprintf(_coverage_fout, "6005\n");
      fflush(_coverage_fout);
      ___coverage_array[6005] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error_noreturn(1, "Cannot get arguments for __call");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6006] == 0) {
      {
      fprintf(_coverage_fout, "6006\n");
      fflush(_coverage_fout);
      ___coverage_array[6006] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6001] == 0) {
        {
        fprintf(_coverage_fout, "6001\n");
        fflush(_coverage_fout);
        ___coverage_array[6001] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6002] == 0) {
        {
        fprintf(_coverage_fout, "6002\n");
        fflush(_coverage_fout);
        ___coverage_array[6002] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6003] == 0) {
        {
        fprintf(_coverage_fout, "6003\n");
        fflush(_coverage_fout);
        ___coverage_array[6003] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6007] == 0) {
      {
      fprintf(_coverage_fout, "6007\n");
      fflush(_coverage_fout);
      ___coverage_array[6007] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6008] == 0) {
      {
      fprintf(_coverage_fout, "6008\n");
      fflush(_coverage_fout);
      ___coverage_array[6008] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6056] == 0) {
    {
    fprintf(_coverage_fout, "6056\n");
    fflush(_coverage_fout);
    ___coverage_array[6056] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6009] == 0) {
      {
      fprintf(_coverage_fout, "6009\n");
      fflush(_coverage_fout);
      ___coverage_array[6009] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6010] == 0) {
      {
      fprintf(_coverage_fout, "6010\n");
      fflush(_coverage_fout);
      ___coverage_array[6010] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    method_name_ptr = (zval *)tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6011] == 0) {
      {
      fprintf(_coverage_fout, "6011\n");
      fflush(_coverage_fout);
      ___coverage_array[6011] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)method_name_ptr)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6057] == 0) {
    {
    fprintf(_coverage_fout, "6057\n");
    fflush(_coverage_fout);
    ___coverage_array[6057] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_name_ptr->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6058] == 0) {
    {
    fprintf(_coverage_fout, "6058\n");
    fflush(_coverage_fout);
    ___coverage_array[6058] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_name_ptr->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6059] == 0) {
    {
    fprintf(_coverage_fout, "6059\n");
    fflush(_coverage_fout);
    ___coverage_array[6059] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6012] == 0) {
      {
      fprintf(_coverage_fout, "6012\n");
      fflush(_coverage_fout);
      ___coverage_array[6012] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = func->function_name;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6013] == 0) {
      {
      fprintf(_coverage_fout, "6013\n");
      fflush(_coverage_fout);
      ___coverage_array[6013] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0 = method_name_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6014] == 0) {
      {
      fprintf(_coverage_fout, "6014\n");
      fflush(_coverage_fout);
      ___coverage_array[6014] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6015] == 0) {
      {
      fprintf(_coverage_fout, "6015\n");
      fflush(_coverage_fout);
      ___coverage_array[6015] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.str.len = (int )tmp___4;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6016] == 0) {
      {
      fprintf(_coverage_fout, "6016\n");
      fflush(_coverage_fout);
      ___coverage_array[6016] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6017] == 0) {
      {
      fprintf(_coverage_fout, "6017\n");
      fflush(_coverage_fout);
      ___coverage_array[6017] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6060] == 0) {
    {
    fprintf(_coverage_fout, "6060\n");
    fflush(_coverage_fout);
    ___coverage_array[6060] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_call_method(& this_ptr, ce, & ce->__call, "__call",
                   (int )(sizeof("__call") - 1U), & method_result_ptr, 2,
                   method_name_ptr, method_args_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6061] == 0) {
    {
    fprintf(_coverage_fout, "6061\n");
    fflush(_coverage_fout);
    ___coverage_array[6061] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (method_result_ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6042] == 0) {
      {
      fprintf(_coverage_fout, "6042\n");
      fflush(_coverage_fout);
      ___coverage_array[6042] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = zval_isref_p(method_result_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6043] == 0) {
      {
      fprintf(_coverage_fout, "6043\n");
      fflush(_coverage_fout);
      ___coverage_array[6043] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___10) {
      goto _L;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6040] == 0) {
        {
        fprintf(_coverage_fout, "6040\n");
        fflush(_coverage_fout);
        ___coverage_array[6040] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___11 = zval_refcount_p(method_result_ptr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6041] == 0) {
        {
        fprintf(_coverage_fout, "6041\n");
        fflush(_coverage_fout);
        ___coverage_array[6041] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___11 > 1U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6020] == 0) {
          {
          fprintf(_coverage_fout, "6020\n");
          fflush(_coverage_fout);
          ___coverage_array[6020] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _L: /* CIL Label */ 
        tmp___6 = zval_isref_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6021] == 0) {
          {
          fprintf(_coverage_fout, "6021\n");
          fflush(_coverage_fout);
          ___coverage_array[6021] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        is_ref = tmp___6;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6022] == 0) {
          {
          fprintf(_coverage_fout, "6022\n");
          fflush(_coverage_fout);
          ___coverage_array[6022] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___7 = zval_refcount_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6023] == 0) {
          {
          fprintf(_coverage_fout, "6023\n");
          fflush(_coverage_fout);
          ___coverage_array[6023] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        refcount = tmp___7;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6024] == 0) {
          {
          fprintf(_coverage_fout, "6024\n");
          fflush(_coverage_fout);
          ___coverage_array[6024] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6018] == 0) {
            {
            fprintf(_coverage_fout, "6018\n");
            fflush(_coverage_fout);
            ___coverage_array[6018] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->value = method_result_ptr->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6019] == 0) {
            {
            fprintf(_coverage_fout, "6019\n");
            fflush(_coverage_fout);
            ___coverage_array[6019] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->type = method_result_ptr->type;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6025] == 0) {
          {
          fprintf(_coverage_fout, "6025\n");
          fflush(_coverage_fout);
          ___coverage_array[6025] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6026] == 0) {
          {
          fprintf(_coverage_fout, "6026\n");
          fflush(_coverage_fout);
          ___coverage_array[6026] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_ptr_dtor(& method_result_ptr);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6027] == 0) {
          {
          fprintf(_coverage_fout, "6027\n");
          fflush(_coverage_fout);
          ___coverage_array[6027] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_isref_to_p(return_value, is_ref);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6028] == 0) {
          {
          fprintf(_coverage_fout, "6028\n");
          fflush(_coverage_fout);
          ___coverage_array[6028] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_refcount_p(return_value, refcount);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6031] == 0) {
          {
          fprintf(_coverage_fout, "6031\n");
          fflush(_coverage_fout);
          ___coverage_array[6031] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = zval_isref_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6032] == 0) {
          {
          fprintf(_coverage_fout, "6032\n");
          fflush(_coverage_fout);
          ___coverage_array[6032] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        is_ref___0 = tmp___8;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6033] == 0) {
          {
          fprintf(_coverage_fout, "6033\n");
          fflush(_coverage_fout);
          ___coverage_array[6033] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___9 = zval_refcount_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6034] == 0) {
          {
          fprintf(_coverage_fout, "6034\n");
          fflush(_coverage_fout);
          ___coverage_array[6034] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        refcount___0 = tmp___9;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6035] == 0) {
          {
          fprintf(_coverage_fout, "6035\n");
          fflush(_coverage_fout);
          ___coverage_array[6035] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6029] == 0) {
            {
            fprintf(_coverage_fout, "6029\n");
            fflush(_coverage_fout);
            ___coverage_array[6029] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->value = method_result_ptr->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6030] == 0) {
            {
            fprintf(_coverage_fout, "6030\n");
            fflush(_coverage_fout);
            ___coverage_array[6030] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->type = method_result_ptr->type;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6036] == 0) {
          {
          fprintf(_coverage_fout, "6036\n");
          fflush(_coverage_fout);
          ___coverage_array[6036] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        method_result_ptr->type = (unsigned char)0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6037] == 0) {
          {
          fprintf(_coverage_fout, "6037\n");
          fflush(_coverage_fout);
          ___coverage_array[6037] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_ptr_dtor(& method_result_ptr);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6038] == 0) {
          {
          fprintf(_coverage_fout, "6038\n");
          fflush(_coverage_fout);
          ___coverage_array[6038] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_isref_to_p(return_value, is_ref___0);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6039] == 0) {
          {
          fprintf(_coverage_fout, "6039\n");
          fflush(_coverage_fout);
          ___coverage_array[6039] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_refcount_p(return_value, refcount___0);
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6044] == 0) {
      {
      fprintf(_coverage_fout, "6044\n");
      fflush(_coverage_fout);
      ___coverage_array[6044] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6062] == 0) {
    {
    fprintf(_coverage_fout, "6062\n");
    fflush(_coverage_fout);
    ___coverage_array[6062] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& method_args_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6063] == 0) {
    {
    fprintf(_coverage_fout, "6063\n");
    fflush(_coverage_fout);
    ___coverage_array[6063] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& method_name_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6064] == 0) {
    {
    fprintf(_coverage_fout, "6064\n");
    fflush(_coverage_fout);
    ___coverage_array[6064] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree((void *)func);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6065] == 0) {
    {
    fprintf(_coverage_fout, "6065\n");
    fflush(_coverage_fout);
    ___coverage_array[6065] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static zend_function *zend_check_private_int(zend_function *fbc ,
                                                      zend_class_entry *ce ,
                                                      char *function_name_strval ,
                                                      int function_name_strlen ,
                                                      ulong hash_value ) 
{ int __attribute__((__visibility__("default")))  tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6085] == 0) {
    {
    fprintf(_coverage_fout, "6085\n");
    fflush(_coverage_fout);
    ___coverage_array[6085] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! ce) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6066] == 0) {
      {
      fprintf(_coverage_fout, "6066\n");
      fflush(_coverage_fout);
      ___coverage_array[6066] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((zend_function *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6067] == 0) {
      {
      fprintf(_coverage_fout, "6067\n");
      fflush(_coverage_fout);
      ___coverage_array[6067] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6086] == 0) {
    {
    fprintf(_coverage_fout, "6086\n");
    fflush(_coverage_fout);
    ___coverage_array[6086] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )fbc->common.scope == (unsigned int )ce) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6070] == 0) {
      {
      fprintf(_coverage_fout, "6070\n");
      fflush(_coverage_fout);
      ___coverage_array[6070] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )executor_globals.scope == (unsigned int )ce) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6068] == 0) {
        {
        fprintf(_coverage_fout, "6068\n");
        fflush(_coverage_fout);
        ___coverage_array[6068] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (fbc);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6069] == 0) {
        {
        fprintf(_coverage_fout, "6069\n");
        fflush(_coverage_fout);
        ___coverage_array[6069] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6071] == 0) {
      {
      fprintf(_coverage_fout, "6071\n");
      fflush(_coverage_fout);
      ___coverage_array[6071] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6087] == 0) {
    {
    fprintf(_coverage_fout, "6087\n");
    fflush(_coverage_fout);
    ___coverage_array[6087] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = ce->parent;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6088] == 0) {
    {
    fprintf(_coverage_fout, "6088\n");
    fflush(_coverage_fout);
    ___coverage_array[6088] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6082] == 0) {
      {
      fprintf(_coverage_fout, "6082\n");
      fflush(_coverage_fout);
      ___coverage_array[6082] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (ce) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6072] == 0) {
        {
        fprintf(_coverage_fout, "6072\n");
        fflush(_coverage_fout);
        ___coverage_array[6072] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6083] == 0) {
      {
      fprintf(_coverage_fout, "6083\n");
      fflush(_coverage_fout);
      ___coverage_array[6083] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )ce == (unsigned int )executor_globals.scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6079] == 0) {
        {
        fprintf(_coverage_fout, "6079\n");
        fflush(_coverage_fout);
        ___coverage_array[6079] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = zend_hash_quick_find((HashTable const   *)(& ce->function_table),
                                 (char const   *)function_name_strval,
                                 (unsigned int )(function_name_strlen + 1),
                                 hash_value, (void **)(& fbc));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6080] == 0) {
        {
        fprintf(_coverage_fout, "6080\n");
        fflush(_coverage_fout);
        ___coverage_array[6080] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp == (int __attribute__((__visibility__("default")))  )0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6077] == 0) {
          {
          fprintf(_coverage_fout, "6077\n");
          fflush(_coverage_fout);
          ___coverage_array[6077] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (fbc->op_array.fn_flags & 1024U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6075] == 0) {
            {
            fprintf(_coverage_fout, "6075\n");
            fflush(_coverage_fout);
            ___coverage_array[6075] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )fbc->common.scope == (unsigned int )executor_globals.scope) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6073] == 0) {
              {
              fprintf(_coverage_fout, "6073\n");
              fflush(_coverage_fout);
              ___coverage_array[6073] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return (fbc);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6074] == 0) {
              {
              fprintf(_coverage_fout, "6074\n");
              fflush(_coverage_fout);
              ___coverage_array[6074] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6076] == 0) {
            {
            fprintf(_coverage_fout, "6076\n");
            fflush(_coverage_fout);
            ___coverage_array[6076] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6078] == 0) {
          {
          fprintf(_coverage_fout, "6078\n");
          fflush(_coverage_fout);
          ___coverage_array[6078] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6081] == 0) {
        {
        fprintf(_coverage_fout, "6081\n");
        fflush(_coverage_fout);
        ___coverage_array[6081] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6084] == 0) {
      {
      fprintf(_coverage_fout, "6084\n");
      fflush(_coverage_fout);
      ___coverage_array[6084] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce = ce->parent;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6089] == 0) {
    {
    fprintf(_coverage_fout, "6089\n");
    fflush(_coverage_fout);
    ___coverage_array[6089] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zend_function *)((void *)0));
}
}
int __attribute__((__visibility__("default")))  zend_check_private(union _zend_function *fbc ,
                                                                   zend_class_entry *ce ,
                                                                   char *function_name_strval ,
                                                                   int function_name_strlen ) 
{ ulong __attribute__((__visibility__("default")))  tmp ;
  zend_function *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6090] == 0) {
    {
    fprintf(_coverage_fout, "6090\n");
    fflush(_coverage_fout);
    ___coverage_array[6090] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_hash_func((char const   *)function_name_strval,
                       (unsigned int )(function_name_strlen + 1));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6091] == 0) {
    {
    fprintf(_coverage_fout, "6091\n");
    fflush(_coverage_fout);
    ___coverage_array[6091] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_check_private_int(fbc, ce, function_name_strval,
                                   function_name_strlen, (unsigned long )tmp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6092] == 0) {
    {
    fprintf(_coverage_fout, "6092\n");
    fflush(_coverage_fout);
    ___coverage_array[6092] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )((unsigned int )tmp___0 != (unsigned int )((void *)0)));
}
}
int __attribute__((__visibility__("default")))  zend_check_protected(zend_class_entry *ce ,
                                                                     zend_class_entry *scope ) 
{ zend_class_entry *fbc_scope ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6105] == 0) {
    {
    fprintf(_coverage_fout, "6105\n");
    fflush(_coverage_fout);
    ___coverage_array[6105] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  fbc_scope = ce;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6106] == 0) {
    {
    fprintf(_coverage_fout, "6106\n");
    fflush(_coverage_fout);
    ___coverage_array[6106] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6096] == 0) {
      {
      fprintf(_coverage_fout, "6096\n");
      fflush(_coverage_fout);
      ___coverage_array[6096] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (fbc_scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6093] == 0) {
        {
        fprintf(_coverage_fout, "6093\n");
        fflush(_coverage_fout);
        ___coverage_array[6093] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6097] == 0) {
      {
      fprintf(_coverage_fout, "6097\n");
      fflush(_coverage_fout);
      ___coverage_array[6097] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )fbc_scope == (unsigned int )scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6094] == 0) {
        {
        fprintf(_coverage_fout, "6094\n");
        fflush(_coverage_fout);
        ___coverage_array[6094] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((int __attribute__((__visibility__("default")))  )1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6095] == 0) {
        {
        fprintf(_coverage_fout, "6095\n");
        fflush(_coverage_fout);
        ___coverage_array[6095] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6098] == 0) {
      {
      fprintf(_coverage_fout, "6098\n");
      fflush(_coverage_fout);
      ___coverage_array[6098] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    fbc_scope = fbc_scope->parent;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6107] == 0) {
    {
    fprintf(_coverage_fout, "6107\n");
    fflush(_coverage_fout);
    ___coverage_array[6107] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6102] == 0) {
      {
      fprintf(_coverage_fout, "6102\n");
      fflush(_coverage_fout);
      ___coverage_array[6102] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6099] == 0) {
        {
        fprintf(_coverage_fout, "6099\n");
        fflush(_coverage_fout);
        ___coverage_array[6099] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6103] == 0) {
      {
      fprintf(_coverage_fout, "6103\n");
      fflush(_coverage_fout);
      ___coverage_array[6103] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )scope == (unsigned int )ce) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6100] == 0) {
        {
        fprintf(_coverage_fout, "6100\n");
        fflush(_coverage_fout);
        ___coverage_array[6100] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((int __attribute__((__visibility__("default")))  )1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6101] == 0) {
        {
        fprintf(_coverage_fout, "6101\n");
        fflush(_coverage_fout);
        ___coverage_array[6101] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6104] == 0) {
      {
      fprintf(_coverage_fout, "6104\n");
      fflush(_coverage_fout);
      ___coverage_array[6104] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    scope = scope->parent;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6108] == 0) {
    {
    fprintf(_coverage_fout, "6108\n");
    fflush(_coverage_fout);
    ___coverage_array[6108] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )0);
}
}
__inline static zend_class_entry *zend_get_function_root_class(zend_function *fbc ) 
{ zend_class_entry *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6111] == 0) {
    {
    fprintf(_coverage_fout, "6111\n");
    fflush(_coverage_fout);
    ___coverage_array[6111] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (fbc->common.prototype) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6109] == 0) {
      {
      fprintf(_coverage_fout, "6109\n");
      fflush(_coverage_fout);
      ___coverage_array[6109] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (fbc->common.prototype)->common.scope;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6110] == 0) {
      {
      fprintf(_coverage_fout, "6110\n");
      fflush(_coverage_fout);
      ___coverage_array[6110] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = fbc->common.scope;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6112] == 0) {
    {
    fprintf(_coverage_fout, "6112\n");
    fflush(_coverage_fout);
    ___coverage_array[6112] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline static union _zend_function *zend_get_user_call_function(zend_class_entry *ce ,
                                                                  char const   *method_name ,
                                                                  int method_len ) 
{ zend_internal_function *call_user_call ;
  void __attribute__((__visibility__("default")))  *tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6115] == 0) {
    {
    fprintf(_coverage_fout, "6115\n");
    fflush(_coverage_fout);
    ___coverage_array[6115] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(zend_internal_function ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6116] == 0) {
    {
    fprintf(_coverage_fout, "6116\n");
    fflush(_coverage_fout);
    ___coverage_array[6116] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call = (zend_internal_function *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6117] == 0) {
    {
    fprintf(_coverage_fout, "6117\n");
    fflush(_coverage_fout);
    ___coverage_array[6117] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6118] == 0) {
    {
    fprintf(_coverage_fout, "6118\n");
    fflush(_coverage_fout);
    ___coverage_array[6118] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )ce->type == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6113] == 0) {
      {
      fprintf(_coverage_fout, "6113\n");
      fflush(_coverage_fout);
      ___coverage_array[6113] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    call_user_call->module = ce->info.internal.module;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6114] == 0) {
      {
      fprintf(_coverage_fout, "6114\n");
      fflush(_coverage_fout);
      ___coverage_array[6114] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    call_user_call->module = (struct _zend_module_entry *)((void *)0);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6119] == 0) {
    {
    fprintf(_coverage_fout, "6119\n");
    fflush(_coverage_fout);
    ___coverage_array[6119] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->handler = (void (*)(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ))(& zend_std_call_user_call);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6120] == 0) {
    {
    fprintf(_coverage_fout, "6120\n");
    fflush(_coverage_fout);
    ___coverage_array[6120] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->arg_info = (zend_arg_info *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6121] == 0) {
    {
    fprintf(_coverage_fout, "6121\n");
    fflush(_coverage_fout);
    ___coverage_array[6121] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->num_args = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6122] == 0) {
    {
    fprintf(_coverage_fout, "6122\n");
    fflush(_coverage_fout);
    ___coverage_array[6122] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->scope = ce;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6123] == 0) {
    {
    fprintf(_coverage_fout, "6123\n");
    fflush(_coverage_fout);
    ___coverage_array[6123] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->fn_flags = 2097152U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6124] == 0) {
    {
    fprintf(_coverage_fout, "6124\n");
    fflush(_coverage_fout);
    ___coverage_array[6124] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = _estrndup(method_name, (unsigned int )method_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6125] == 0) {
    {
    fprintf(_coverage_fout, "6125\n");
    fflush(_coverage_fout);
    ___coverage_array[6125] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  call_user_call->function_name = (char const   *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6126] == 0) {
    {
    fprintf(_coverage_fout, "6126\n");
    fflush(_coverage_fout);
    ___coverage_array[6126] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((union _zend_function *)call_user_call);
}
}
static union _zend_function *zend_std_get_method(zval **object_ptr ,
                                                 char *method_name ,
                                                 int method_len ,
                                                 zend_literal const   *key ) 
{ zend_function *fbc ;
  zval *object ;
  zend_object *zobj ;
  ulong hash_value ;
  char *lc_method_name ;
  zend_bool use_heap ;
  long tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  long tmp___2 ;
  ulong __attribute__((__visibility__("default")))  tmp___3 ;
  long tmp___4 ;
  long tmp___5 ;
  long tmp___6 ;
  union _zend_function *tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;
  long tmp___9 ;
  zend_function *updated_fbc ;
  zend_class_entry *tmp___10 ;
  char const   *tmp___11 ;
  char const   *tmp___12 ;
  char *tmp___13 ;
  long tmp___14 ;
  zend_function *priv_fbc ;
  int __attribute__((__visibility__("default")))  tmp___15 ;
  zend_bool tmp___16 ;
  char const   *tmp___17 ;
  char const   *tmp___18 ;
  char *tmp___19 ;
  zend_class_entry *tmp___20 ;
  int __attribute__((__visibility__("default")))  tmp___21 ;
  int tmp___22 ;
  long tmp___23 ;
  long tmp___24 ;
  long tmp___25 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6212] == 0) {
    {
    fprintf(_coverage_fout, "6212\n");
    fflush(_coverage_fout);
    ___coverage_array[6212] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object = *object_ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6213] == 0) {
    {
    fprintf(_coverage_fout, "6213\n");
    fflush(_coverage_fout);
    ___coverage_array[6213] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6214] == 0) {
    {
    fprintf(_coverage_fout, "6214\n");
    fflush(_coverage_fout);
    ___coverage_array[6214] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )key != (unsigned int )((void *)0)),
                             1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6215] == 0) {
    {
    fprintf(_coverage_fout, "6215\n");
    fflush(_coverage_fout);
    ___coverage_array[6215] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6127] == 0) {
      {
      fprintf(_coverage_fout, "6127\n");
      fflush(_coverage_fout);
      ___coverage_array[6127] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    lc_method_name = (char *)key->constant.value.str.val;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6128] == 0) {
      {
      fprintf(_coverage_fout, "6128\n");
      fflush(_coverage_fout);
      ___coverage_array[6128] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash_value = (unsigned long )key->hash_value;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6133] == 0) {
      {
      fprintf(_coverage_fout, "6133\n");
      fflush(_coverage_fout);
      ___coverage_array[6133] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = __builtin_expect((long )(method_len + 1 > 32768), 0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6134] == 0) {
      {
      fprintf(_coverage_fout, "6134\n");
      fflush(_coverage_fout);
      ___coverage_array[6134] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    use_heap = (unsigned char )tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6135] == 0) {
      {
      fprintf(_coverage_fout, "6135\n");
      fflush(_coverage_fout);
      ___coverage_array[6135] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (use_heap) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6129] == 0) {
        {
        fprintf(_coverage_fout, "6129\n");
        fflush(_coverage_fout);
        ___coverage_array[6129] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _emalloc((unsigned int )(method_len + 1));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6130] == 0) {
        {
        fprintf(_coverage_fout, "6130\n");
        fflush(_coverage_fout);
        ___coverage_array[6130] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      lc_method_name = (char *)tmp___0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6131] == 0) {
        {
        fprintf(_coverage_fout, "6131\n");
        fflush(_coverage_fout);
        ___coverage_array[6131] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = __builtin_alloca((unsigned int )(method_len + 1));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6132] == 0) {
        {
        fprintf(_coverage_fout, "6132\n");
        fflush(_coverage_fout);
        ___coverage_array[6132] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      lc_method_name = (char *)tmp___1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6136] == 0) {
      {
      fprintf(_coverage_fout, "6136\n");
      fflush(_coverage_fout);
      ___coverage_array[6136] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_str_tolower_copy(lc_method_name, (char const   *)method_name,
                          (unsigned int )method_len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6137] == 0) {
      {
      fprintf(_coverage_fout, "6137\n");
      fflush(_coverage_fout);
      ___coverage_array[6137] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = zend_hash_func((char const   *)lc_method_name,
                             (unsigned int )(method_len + 1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6138] == 0) {
      {
      fprintf(_coverage_fout, "6138\n");
      fflush(_coverage_fout);
      ___coverage_array[6138] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash_value = (unsigned long )tmp___3;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6216] == 0) {
    {
    fprintf(_coverage_fout, "6216\n");
    fflush(_coverage_fout);
    ___coverage_array[6216] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___8 = zend_hash_quick_find((HashTable const   *)(& (zobj->ce)->function_table),
                                 (char const   *)lc_method_name,
                                 (unsigned int )(method_len + 1), hash_value,
                                 (void **)(& fbc));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6217] == 0) {
    {
    fprintf(_coverage_fout, "6217\n");
    fflush(_coverage_fout);
    ___coverage_array[6217] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___9 = __builtin_expect((long )(tmp___8 == (int __attribute__((__visibility__("default")))  )-1),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6218] == 0) {
    {
    fprintf(_coverage_fout, "6218\n");
    fflush(_coverage_fout);
    ___coverage_array[6218] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___9) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6148] == 0) {
      {
      fprintf(_coverage_fout, "6148\n");
      fflush(_coverage_fout);
      ___coverage_array[6148] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = __builtin_expect((long )(! key), 0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6149] == 0) {
      {
      fprintf(_coverage_fout, "6149\n");
      fflush(_coverage_fout);
      ___coverage_array[6149] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6143] == 0) {
        {
        fprintf(_coverage_fout, "6143\n");
        fflush(_coverage_fout);
        ___coverage_array[6143] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6141] == 0) {
          {
          fprintf(_coverage_fout, "6141\n");
          fflush(_coverage_fout);
          ___coverage_array[6141] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = __builtin_expect((long )use_heap, 0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6142] == 0) {
          {
          fprintf(_coverage_fout, "6142\n");
          fflush(_coverage_fout);
          ___coverage_array[6142] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___5) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6139] == 0) {
            {
            fprintf(_coverage_fout, "6139\n");
            fflush(_coverage_fout);
            ___coverage_array[6139] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _efree((void *)lc_method_name);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6140] == 0) {
            {
            fprintf(_coverage_fout, "6140\n");
            fflush(_coverage_fout);
            ___coverage_array[6140] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        break;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6144] == 0) {
        {
        fprintf(_coverage_fout, "6144\n");
        fflush(_coverage_fout);
        ___coverage_array[6144] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6150] == 0) {
      {
      fprintf(_coverage_fout, "6150\n");
      fflush(_coverage_fout);
      ___coverage_array[6150] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((zobj->ce)->__call) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6145] == 0) {
        {
        fprintf(_coverage_fout, "6145\n");
        fflush(_coverage_fout);
        ___coverage_array[6145] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___7 = zend_get_user_call_function(zobj->ce,
                                            (char const   *)method_name,
                                            method_len);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6146] == 0) {
        {
        fprintf(_coverage_fout, "6146\n");
        fflush(_coverage_fout);
        ___coverage_array[6146] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (tmp___7);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6147] == 0) {
        {
        fprintf(_coverage_fout, "6147\n");
        fflush(_coverage_fout);
        ___coverage_array[6147] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((union _zend_function *)((void *)0));
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6151] == 0) {
      {
      fprintf(_coverage_fout, "6151\n");
      fflush(_coverage_fout);
      ___coverage_array[6151] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6219] == 0) {
    {
    fprintf(_coverage_fout, "6219\n");
    fflush(_coverage_fout);
    ___coverage_array[6219] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (fbc->op_array.fn_flags & 1024U) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6165] == 0) {
      {
      fprintf(_coverage_fout, "6165\n");
      fflush(_coverage_fout);
      ___coverage_array[6165] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = (*((object->value.obj.handlers)->get_class_entry))((zval const   *)object);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6166] == 0) {
      {
      fprintf(_coverage_fout, "6166\n");
      fflush(_coverage_fout);
      ___coverage_array[6166] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    updated_fbc = zend_check_private_int(fbc, tmp___10, lc_method_name,
                                         method_len, hash_value);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6167] == 0) {
      {
      fprintf(_coverage_fout, "6167\n");
      fflush(_coverage_fout);
      ___coverage_array[6167] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___14 = __builtin_expect((long )((unsigned int )updated_fbc != (unsigned int )((void *)0)),
                                1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6168] == 0) {
      {
      fprintf(_coverage_fout, "6168\n");
      fflush(_coverage_fout);
      ___coverage_array[6168] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___14) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6152] == 0) {
        {
        fprintf(_coverage_fout, "6152\n");
        fflush(_coverage_fout);
        ___coverage_array[6152] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      fbc = updated_fbc;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6164] == 0) {
        {
        fprintf(_coverage_fout, "6164\n");
        fflush(_coverage_fout);
        ___coverage_array[6164] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((zobj->ce)->__call) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6153] == 0) {
          {
          fprintf(_coverage_fout, "6153\n");
          fflush(_coverage_fout);
          ___coverage_array[6153] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        fbc = zend_get_user_call_function(zobj->ce, (char const   *)method_name,
                                          method_len);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6160] == 0) {
          {
          fprintf(_coverage_fout, "6160\n");
          fflush(_coverage_fout);
          ___coverage_array[6160] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (executor_globals.scope) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6154] == 0) {
            {
            fprintf(_coverage_fout, "6154\n");
            fflush(_coverage_fout);
            ___coverage_array[6154] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___11 = (executor_globals.scope)->name;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6155] == 0) {
            {
            fprintf(_coverage_fout, "6155\n");
            fflush(_coverage_fout);
            ___coverage_array[6155] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___11 = "";
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6161] == 0) {
          {
          fprintf(_coverage_fout, "6161\n");
          fflush(_coverage_fout);
          ___coverage_array[6161] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (fbc) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6158] == 0) {
            {
            fprintf(_coverage_fout, "6158\n");
            fflush(_coverage_fout);
            ___coverage_array[6158] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (fbc->common.scope) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6156] == 0) {
              {
              fprintf(_coverage_fout, "6156\n");
              fflush(_coverage_fout);
              ___coverage_array[6156] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___12 = (fbc->common.scope)->name;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6157] == 0) {
              {
              fprintf(_coverage_fout, "6157\n");
              fflush(_coverage_fout);
              ___coverage_array[6157] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___12 = "";
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6159] == 0) {
            {
            fprintf(_coverage_fout, "6159\n");
            fflush(_coverage_fout);
            ___coverage_array[6159] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___12 = "";
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6162] == 0) {
          {
          fprintf(_coverage_fout, "6162\n");
          fflush(_coverage_fout);
          ___coverage_array[6162] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___13 = zend_visibility_string(fbc->common.fn_flags);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6163] == 0) {
          {
          fprintf(_coverage_fout, "6163\n");
          fflush(_coverage_fout);
          ___coverage_array[6163] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_error_noreturn(1, "Call to %s method %s::%s() from context \'%s\'",
                            tmp___13, tmp___12, method_name, tmp___11);
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6204] == 0) {
      {
      fprintf(_coverage_fout, "6204\n");
      fflush(_coverage_fout);
      ___coverage_array[6204] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (executor_globals.scope) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6180] == 0) {
        {
        fprintf(_coverage_fout, "6180\n");
        fflush(_coverage_fout);
        ___coverage_array[6180] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___16 = is_derived_class(fbc->common.scope, executor_globals.scope);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6181] == 0) {
        {
        fprintf(_coverage_fout, "6181\n");
        fflush(_coverage_fout);
        ___coverage_array[6181] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___16) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6178] == 0) {
          {
          fprintf(_coverage_fout, "6178\n");
          fflush(_coverage_fout);
          ___coverage_array[6178] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (fbc->op_array.fn_flags & 2048U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6175] == 0) {
            {
            fprintf(_coverage_fout, "6175\n");
            fflush(_coverage_fout);
            ___coverage_array[6175] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___15 = zend_hash_quick_find((HashTable const   *)(& (executor_globals.scope)->function_table),
                                          (char const   *)lc_method_name,
                                          (unsigned int )(method_len + 1),
                                          hash_value, (void **)(& priv_fbc));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6176] == 0) {
            {
            fprintf(_coverage_fout, "6176\n");
            fflush(_coverage_fout);
            ___coverage_array[6176] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___15 == (int __attribute__((__visibility__("default")))  )0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6173] == 0) {
              {
              fprintf(_coverage_fout, "6173\n");
              fflush(_coverage_fout);
              ___coverage_array[6173] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (priv_fbc->common.fn_flags & 1024U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6171] == 0) {
                {
                fprintf(_coverage_fout, "6171\n");
                fflush(_coverage_fout);
                ___coverage_array[6171] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((unsigned int )priv_fbc->common.scope == (unsigned int )executor_globals.scope) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6169] == 0) {
                  {
                  fprintf(_coverage_fout, "6169\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6169] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                fbc = priv_fbc;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6170] == 0) {
                  {
                  fprintf(_coverage_fout, "6170\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6170] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6172] == 0) {
                {
                fprintf(_coverage_fout, "6172\n");
                fflush(_coverage_fout);
                ___coverage_array[6172] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6174] == 0) {
              {
              fprintf(_coverage_fout, "6174\n");
              fflush(_coverage_fout);
              ___coverage_array[6174] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6177] == 0) {
            {
            fprintf(_coverage_fout, "6177\n");
            fflush(_coverage_fout);
            ___coverage_array[6177] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6179] == 0) {
          {
          fprintf(_coverage_fout, "6179\n");
          fflush(_coverage_fout);
          ___coverage_array[6179] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6182] == 0) {
        {
        fprintf(_coverage_fout, "6182\n");
        fflush(_coverage_fout);
        ___coverage_array[6182] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6205] == 0) {
      {
      fprintf(_coverage_fout, "6205\n");
      fflush(_coverage_fout);
      ___coverage_array[6205] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (fbc->common.fn_flags & 512U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6198] == 0) {
        {
        fprintf(_coverage_fout, "6198\n");
        fflush(_coverage_fout);
        ___coverage_array[6198] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___20 = zend_get_function_root_class(fbc);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6199] == 0) {
        {
        fprintf(_coverage_fout, "6199\n");
        fflush(_coverage_fout);
        ___coverage_array[6199] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___21 = zend_check_protected(tmp___20, executor_globals.scope);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6200] == 0) {
        {
        fprintf(_coverage_fout, "6200\n");
        fflush(_coverage_fout);
        ___coverage_array[6200] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___21) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6183] == 0) {
          {
          fprintf(_coverage_fout, "6183\n");
          fflush(_coverage_fout);
          ___coverage_array[6183] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___22 = 0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6184] == 0) {
          {
          fprintf(_coverage_fout, "6184\n");
          fflush(_coverage_fout);
          ___coverage_array[6184] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___22 = 1;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6201] == 0) {
        {
        fprintf(_coverage_fout, "6201\n");
        fflush(_coverage_fout);
        ___coverage_array[6201] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___23 = __builtin_expect((long )tmp___22, 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6202] == 0) {
        {
        fprintf(_coverage_fout, "6202\n");
        fflush(_coverage_fout);
        ___coverage_array[6202] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___23) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6196] == 0) {
          {
          fprintf(_coverage_fout, "6196\n");
          fflush(_coverage_fout);
          ___coverage_array[6196] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((zobj->ce)->__call) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6185] == 0) {
            {
            fprintf(_coverage_fout, "6185\n");
            fflush(_coverage_fout);
            ___coverage_array[6185] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          fbc = zend_get_user_call_function(zobj->ce,
                                            (char const   *)method_name,
                                            method_len);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6192] == 0) {
            {
            fprintf(_coverage_fout, "6192\n");
            fflush(_coverage_fout);
            ___coverage_array[6192] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (executor_globals.scope) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6186] == 0) {
              {
              fprintf(_coverage_fout, "6186\n");
              fflush(_coverage_fout);
              ___coverage_array[6186] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___17 = (executor_globals.scope)->name;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6187] == 0) {
              {
              fprintf(_coverage_fout, "6187\n");
              fflush(_coverage_fout);
              ___coverage_array[6187] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___17 = "";
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6193] == 0) {
            {
            fprintf(_coverage_fout, "6193\n");
            fflush(_coverage_fout);
            ___coverage_array[6193] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (fbc) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6190] == 0) {
              {
              fprintf(_coverage_fout, "6190\n");
              fflush(_coverage_fout);
              ___coverage_array[6190] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (fbc->common.scope) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6188] == 0) {
                {
                fprintf(_coverage_fout, "6188\n");
                fflush(_coverage_fout);
                ___coverage_array[6188] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___18 = (fbc->common.scope)->name;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6189] == 0) {
                {
                fprintf(_coverage_fout, "6189\n");
                fflush(_coverage_fout);
                ___coverage_array[6189] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___18 = "";
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6191] == 0) {
              {
              fprintf(_coverage_fout, "6191\n");
              fflush(_coverage_fout);
              ___coverage_array[6191] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___18 = "";
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6194] == 0) {
            {
            fprintf(_coverage_fout, "6194\n");
            fflush(_coverage_fout);
            ___coverage_array[6194] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___19 = zend_visibility_string(fbc->common.fn_flags);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6195] == 0) {
            {
            fprintf(_coverage_fout, "6195\n");
            fflush(_coverage_fout);
            ___coverage_array[6195] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1,
                              "Call to %s method %s::%s() from context \'%s\'",
                              tmp___19, tmp___18, method_name, tmp___17);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6197] == 0) {
          {
          fprintf(_coverage_fout, "6197\n");
          fflush(_coverage_fout);
          ___coverage_array[6197] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6203] == 0) {
        {
        fprintf(_coverage_fout, "6203\n");
        fflush(_coverage_fout);
        ___coverage_array[6203] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6220] == 0) {
    {
    fprintf(_coverage_fout, "6220\n");
    fflush(_coverage_fout);
    ___coverage_array[6220] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___25 = __builtin_expect((long )(! key), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6221] == 0) {
    {
    fprintf(_coverage_fout, "6221\n");
    fflush(_coverage_fout);
    ___coverage_array[6221] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___25) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6210] == 0) {
      {
      fprintf(_coverage_fout, "6210\n");
      fflush(_coverage_fout);
      ___coverage_array[6210] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6208] == 0) {
        {
        fprintf(_coverage_fout, "6208\n");
        fflush(_coverage_fout);
        ___coverage_array[6208] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___24 = __builtin_expect((long )use_heap, 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6209] == 0) {
        {
        fprintf(_coverage_fout, "6209\n");
        fflush(_coverage_fout);
        ___coverage_array[6209] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___24) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6206] == 0) {
          {
          fprintf(_coverage_fout, "6206\n");
          fflush(_coverage_fout);
          ___coverage_array[6206] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _efree((void *)lc_method_name);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6207] == 0) {
          {
          fprintf(_coverage_fout, "6207\n");
          fflush(_coverage_fout);
          ___coverage_array[6207] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6211] == 0) {
      {
      fprintf(_coverage_fout, "6211\n");
      fflush(_coverage_fout);
      ___coverage_array[6211] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6222] == 0) {
    {
    fprintf(_coverage_fout, "6222\n");
    fflush(_coverage_fout);
    ___coverage_array[6222] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (fbc);
}
}
void __attribute__((__visibility__("default")))  zend_std_callstatic_user_call(int ht ,
                                                                               zval *return_value ,
                                                                               zval **return_value_ptr ,
                                                                               zval *this_ptr ,
                                                                               int return_value_used ) 
{ zend_internal_function *func ;
  zval *method_name_ptr ;
  zval *method_args_ptr ;
  zval *method_result_ptr ;
  zend_class_entry *ce ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  long tmp___1 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___3 ;
  char __attribute__((__visibility__("default")))  *tmp___4 ;
  zend_uchar is_ref ;
  zend_bool tmp___5 ;
  zend_uint refcount ;
  zend_uint tmp___6 ;
  zend_uchar is_ref___0 ;
  zend_bool tmp___7 ;
  zend_uint refcount___0 ;
  zend_uint tmp___8 ;
  zend_bool tmp___9 ;
  zend_uint tmp___10 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6270] == 0) {
    {
    fprintf(_coverage_fout, "6270\n");
    fflush(_coverage_fout);
    ___coverage_array[6270] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  func = (zend_internal_function *)(executor_globals.current_execute_data)->function_state.function;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6271] == 0) {
    {
    fprintf(_coverage_fout, "6271\n");
    fflush(_coverage_fout);
    ___coverage_array[6271] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_result_ptr = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6272] == 0) {
    {
    fprintf(_coverage_fout, "6272\n");
    fflush(_coverage_fout);
    ___coverage_array[6272] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = executor_globals.scope;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6273] == 0) {
    {
    fprintf(_coverage_fout, "6273\n");
    fflush(_coverage_fout);
    ___coverage_array[6273] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6223] == 0) {
      {
      fprintf(_coverage_fout, "6223\n");
      fflush(_coverage_fout);
      ___coverage_array[6223] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6224] == 0) {
      {
      fprintf(_coverage_fout, "6224\n");
      fflush(_coverage_fout);
      ___coverage_array[6224] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    method_args_ptr = (zval *)tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6225] == 0) {
      {
      fprintf(_coverage_fout, "6225\n");
      fflush(_coverage_fout);
      ___coverage_array[6225] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)method_args_ptr)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6274] == 0) {
    {
    fprintf(_coverage_fout, "6274\n");
    fflush(_coverage_fout);
    ___coverage_array[6274] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_args_ptr->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6275] == 0) {
    {
    fprintf(_coverage_fout, "6275\n");
    fflush(_coverage_fout);
    ___coverage_array[6275] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_args_ptr->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6276] == 0) {
    {
    fprintf(_coverage_fout, "6276\n");
    fflush(_coverage_fout);
    ___coverage_array[6276] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(method_args_ptr, (unsigned int )ht);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6277] == 0) {
    {
    fprintf(_coverage_fout, "6277\n");
    fflush(_coverage_fout);
    ___coverage_array[6277] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_copy_parameters_array(ht, method_args_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6278] == 0) {
    {
    fprintf(_coverage_fout, "6278\n");
    fflush(_coverage_fout);
    ___coverage_array[6278] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = __builtin_expect((long )(tmp___0 == (int __attribute__((__visibility__("default")))  )-1),
                             0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6279] == 0) {
    {
    fprintf(_coverage_fout, "6279\n");
    fflush(_coverage_fout);
    ___coverage_array[6279] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6229] == 0) {
      {
      fprintf(_coverage_fout, "6229\n");
      fflush(_coverage_fout);
      ___coverage_array[6229] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(method_args_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6230] == 0) {
      {
      fprintf(_coverage_fout, "6230\n");
      fflush(_coverage_fout);
      ___coverage_array[6230] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error_noreturn(1, "Cannot get arguments for __callstatic");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6231] == 0) {
      {
      fprintf(_coverage_fout, "6231\n");
      fflush(_coverage_fout);
      ___coverage_array[6231] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6226] == 0) {
        {
        fprintf(_coverage_fout, "6226\n");
        fflush(_coverage_fout);
        ___coverage_array[6226] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6227] == 0) {
        {
        fprintf(_coverage_fout, "6227\n");
        fflush(_coverage_fout);
        ___coverage_array[6227] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6228] == 0) {
        {
        fprintf(_coverage_fout, "6228\n");
        fflush(_coverage_fout);
        ___coverage_array[6228] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6232] == 0) {
      {
      fprintf(_coverage_fout, "6232\n");
      fflush(_coverage_fout);
      ___coverage_array[6232] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6233] == 0) {
      {
      fprintf(_coverage_fout, "6233\n");
      fflush(_coverage_fout);
      ___coverage_array[6233] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6280] == 0) {
    {
    fprintf(_coverage_fout, "6280\n");
    fflush(_coverage_fout);
    ___coverage_array[6280] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6234] == 0) {
      {
      fprintf(_coverage_fout, "6234\n");
      fflush(_coverage_fout);
      ___coverage_array[6234] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6235] == 0) {
      {
      fprintf(_coverage_fout, "6235\n");
      fflush(_coverage_fout);
      ___coverage_array[6235] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    method_name_ptr = (zval *)tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6236] == 0) {
      {
      fprintf(_coverage_fout, "6236\n");
      fflush(_coverage_fout);
      ___coverage_array[6236] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)method_name_ptr)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6281] == 0) {
    {
    fprintf(_coverage_fout, "6281\n");
    fflush(_coverage_fout);
    ___coverage_array[6281] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_name_ptr->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6282] == 0) {
    {
    fprintf(_coverage_fout, "6282\n");
    fflush(_coverage_fout);
    ___coverage_array[6282] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  method_name_ptr->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6283] == 0) {
    {
    fprintf(_coverage_fout, "6283\n");
    fflush(_coverage_fout);
    ___coverage_array[6283] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6237] == 0) {
      {
      fprintf(_coverage_fout, "6237\n");
      fflush(_coverage_fout);
      ___coverage_array[6237] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = func->function_name;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6238] == 0) {
      {
      fprintf(_coverage_fout, "6238\n");
      fflush(_coverage_fout);
      ___coverage_array[6238] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0 = method_name_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6239] == 0) {
      {
      fprintf(_coverage_fout, "6239\n");
      fflush(_coverage_fout);
      ___coverage_array[6239] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6240] == 0) {
      {
      fprintf(_coverage_fout, "6240\n");
      fflush(_coverage_fout);
      ___coverage_array[6240] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.str.len = (int )tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6241] == 0) {
      {
      fprintf(_coverage_fout, "6241\n");
      fflush(_coverage_fout);
      ___coverage_array[6241] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6242] == 0) {
      {
      fprintf(_coverage_fout, "6242\n");
      fflush(_coverage_fout);
      ___coverage_array[6242] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6284] == 0) {
    {
    fprintf(_coverage_fout, "6284\n");
    fflush(_coverage_fout);
    ___coverage_array[6284] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_call_method((zval **)((void *)0), ce, & ce->__callstatic, "__callstatic",
                   (int )(sizeof("__callstatic") - 1U), & method_result_ptr, 2,
                   method_name_ptr, method_args_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6285] == 0) {
    {
    fprintf(_coverage_fout, "6285\n");
    fflush(_coverage_fout);
    ___coverage_array[6285] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (method_result_ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6267] == 0) {
      {
      fprintf(_coverage_fout, "6267\n");
      fflush(_coverage_fout);
      ___coverage_array[6267] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = zval_isref_p(method_result_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6268] == 0) {
      {
      fprintf(_coverage_fout, "6268\n");
      fflush(_coverage_fout);
      ___coverage_array[6268] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___9) {
      goto _L;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6265] == 0) {
        {
        fprintf(_coverage_fout, "6265\n");
        fflush(_coverage_fout);
        ___coverage_array[6265] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___10 = zval_refcount_p(method_result_ptr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6266] == 0) {
        {
        fprintf(_coverage_fout, "6266\n");
        fflush(_coverage_fout);
        ___coverage_array[6266] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___10 > 1U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6245] == 0) {
          {
          fprintf(_coverage_fout, "6245\n");
          fflush(_coverage_fout);
          ___coverage_array[6245] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _L: /* CIL Label */ 
        tmp___5 = zval_isref_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6246] == 0) {
          {
          fprintf(_coverage_fout, "6246\n");
          fflush(_coverage_fout);
          ___coverage_array[6246] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        is_ref = tmp___5;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6247] == 0) {
          {
          fprintf(_coverage_fout, "6247\n");
          fflush(_coverage_fout);
          ___coverage_array[6247] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___6 = zval_refcount_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6248] == 0) {
          {
          fprintf(_coverage_fout, "6248\n");
          fflush(_coverage_fout);
          ___coverage_array[6248] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        refcount = tmp___6;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6249] == 0) {
          {
          fprintf(_coverage_fout, "6249\n");
          fflush(_coverage_fout);
          ___coverage_array[6249] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6243] == 0) {
            {
            fprintf(_coverage_fout, "6243\n");
            fflush(_coverage_fout);
            ___coverage_array[6243] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->value = method_result_ptr->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6244] == 0) {
            {
            fprintf(_coverage_fout, "6244\n");
            fflush(_coverage_fout);
            ___coverage_array[6244] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->type = method_result_ptr->type;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6250] == 0) {
          {
          fprintf(_coverage_fout, "6250\n");
          fflush(_coverage_fout);
          ___coverage_array[6250] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6251] == 0) {
          {
          fprintf(_coverage_fout, "6251\n");
          fflush(_coverage_fout);
          ___coverage_array[6251] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_ptr_dtor(& method_result_ptr);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6252] == 0) {
          {
          fprintf(_coverage_fout, "6252\n");
          fflush(_coverage_fout);
          ___coverage_array[6252] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_isref_to_p(return_value, is_ref);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6253] == 0) {
          {
          fprintf(_coverage_fout, "6253\n");
          fflush(_coverage_fout);
          ___coverage_array[6253] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_refcount_p(return_value, refcount);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6256] == 0) {
          {
          fprintf(_coverage_fout, "6256\n");
          fflush(_coverage_fout);
          ___coverage_array[6256] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___7 = zval_isref_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6257] == 0) {
          {
          fprintf(_coverage_fout, "6257\n");
          fflush(_coverage_fout);
          ___coverage_array[6257] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        is_ref___0 = tmp___7;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6258] == 0) {
          {
          fprintf(_coverage_fout, "6258\n");
          fflush(_coverage_fout);
          ___coverage_array[6258] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = zval_refcount_p(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6259] == 0) {
          {
          fprintf(_coverage_fout, "6259\n");
          fflush(_coverage_fout);
          ___coverage_array[6259] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        refcount___0 = tmp___8;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6260] == 0) {
          {
          fprintf(_coverage_fout, "6260\n");
          fflush(_coverage_fout);
          ___coverage_array[6260] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6254] == 0) {
            {
            fprintf(_coverage_fout, "6254\n");
            fflush(_coverage_fout);
            ___coverage_array[6254] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->value = method_result_ptr->value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6255] == 0) {
            {
            fprintf(_coverage_fout, "6255\n");
            fflush(_coverage_fout);
            ___coverage_array[6255] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return_value->type = method_result_ptr->type;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6261] == 0) {
          {
          fprintf(_coverage_fout, "6261\n");
          fflush(_coverage_fout);
          ___coverage_array[6261] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        method_result_ptr->type = (unsigned char)0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6262] == 0) {
          {
          fprintf(_coverage_fout, "6262\n");
          fflush(_coverage_fout);
          ___coverage_array[6262] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_ptr_dtor(& method_result_ptr);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6263] == 0) {
          {
          fprintf(_coverage_fout, "6263\n");
          fflush(_coverage_fout);
          ___coverage_array[6263] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_isref_to_p(return_value, is_ref___0);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6264] == 0) {
          {
          fprintf(_coverage_fout, "6264\n");
          fflush(_coverage_fout);
          ___coverage_array[6264] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zval_set_refcount_p(return_value, refcount___0);
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6269] == 0) {
      {
      fprintf(_coverage_fout, "6269\n");
      fflush(_coverage_fout);
      ___coverage_array[6269] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6286] == 0) {
    {
    fprintf(_coverage_fout, "6286\n");
    fflush(_coverage_fout);
    ___coverage_array[6286] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& method_args_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6287] == 0) {
    {
    fprintf(_coverage_fout, "6287\n");
    fflush(_coverage_fout);
    ___coverage_array[6287] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& method_name_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6288] == 0) {
    {
    fprintf(_coverage_fout, "6288\n");
    fflush(_coverage_fout);
    ___coverage_array[6288] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree((void *)func);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6289] == 0) {
    {
    fprintf(_coverage_fout, "6289\n");
    fflush(_coverage_fout);
    ___coverage_array[6289] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static union _zend_function *zend_get_user_callstatic_function(zend_class_entry *ce ,
                                                                        char const   *method_name ,
                                                                        int method_len ) 
{ zend_internal_function *callstatic_user_call ;
  void __attribute__((__visibility__("default")))  *tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6292] == 0) {
    {
    fprintf(_coverage_fout, "6292\n");
    fflush(_coverage_fout);
    ___coverage_array[6292] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(zend_internal_function ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6293] == 0) {
    {
    fprintf(_coverage_fout, "6293\n");
    fflush(_coverage_fout);
    ___coverage_array[6293] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call = (zend_internal_function *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6294] == 0) {
    {
    fprintf(_coverage_fout, "6294\n");
    fflush(_coverage_fout);
    ___coverage_array[6294] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6295] == 0) {
    {
    fprintf(_coverage_fout, "6295\n");
    fflush(_coverage_fout);
    ___coverage_array[6295] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )ce->type == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6290] == 0) {
      {
      fprintf(_coverage_fout, "6290\n");
      fflush(_coverage_fout);
      ___coverage_array[6290] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    callstatic_user_call->module = ce->info.internal.module;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6291] == 0) {
      {
      fprintf(_coverage_fout, "6291\n");
      fflush(_coverage_fout);
      ___coverage_array[6291] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    callstatic_user_call->module = (struct _zend_module_entry *)((void *)0);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6296] == 0) {
    {
    fprintf(_coverage_fout, "6296\n");
    fflush(_coverage_fout);
    ___coverage_array[6296] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->handler = (void (*)(int ht , zval *return_value ,
                                            zval **return_value_ptr ,
                                            zval *this_ptr ,
                                            int return_value_used ))(& zend_std_callstatic_user_call);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6297] == 0) {
    {
    fprintf(_coverage_fout, "6297\n");
    fflush(_coverage_fout);
    ___coverage_array[6297] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->arg_info = (zend_arg_info *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6298] == 0) {
    {
    fprintf(_coverage_fout, "6298\n");
    fflush(_coverage_fout);
    ___coverage_array[6298] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->num_args = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6299] == 0) {
    {
    fprintf(_coverage_fout, "6299\n");
    fflush(_coverage_fout);
    ___coverage_array[6299] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->scope = ce;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6300] == 0) {
    {
    fprintf(_coverage_fout, "6300\n");
    fflush(_coverage_fout);
    ___coverage_array[6300] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->fn_flags = 2097409U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6301] == 0) {
    {
    fprintf(_coverage_fout, "6301\n");
    fflush(_coverage_fout);
    ___coverage_array[6301] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = _estrndup(method_name, (unsigned int )method_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6302] == 0) {
    {
    fprintf(_coverage_fout, "6302\n");
    fflush(_coverage_fout);
    ___coverage_array[6302] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  callstatic_user_call->function_name = (char const   *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6303] == 0) {
    {
    fprintf(_coverage_fout, "6303\n");
    fflush(_coverage_fout);
    ___coverage_array[6303] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zend_function *)callstatic_user_call);
}
}
union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_static_method(zend_class_entry *ce ,
                                                                                             char const   *function_name_strval ,
                                                                                             int function_name_strlen ,
                                                                                             struct _zend_literal  const  *key ) 
{ zend_function *fbc ;
  char *lc_class_name ;
  char *lc_function_name ;
  ulong hash_value ;
  zend_bool use_heap ;
  long tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  long tmp___2 ;
  ulong __attribute__((__visibility__("default")))  tmp___3 ;
  long tmp___4 ;
  char __attribute__((__visibility__("default")))  *tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;
  long tmp___8 ;
  long tmp___9 ;
  union _zend_function *tmp___10 ;
  union _zend_function *tmp___11 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___12 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___13 ;
  long tmp___14 ;
  int __attribute__((__visibility__("default")))  tmp___15 ;
  long tmp___16 ;
  zend_function *updated_fbc ;
  char const   *tmp___17 ;
  char const   *tmp___18 ;
  char *tmp___19 ;
  long tmp___20 ;
  char const   *tmp___21 ;
  char const   *tmp___22 ;
  char *tmp___23 ;
  zend_class_entry *tmp___24 ;
  int __attribute__((__visibility__("default")))  tmp___25 ;
  int tmp___26 ;
  long tmp___27 ;
  long tmp___28 ;
  long tmp___29 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6400] == 0) {
    {
    fprintf(_coverage_fout, "6400\n");
    fflush(_coverage_fout);
    ___coverage_array[6400] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  fbc = (zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6401] == 0) {
    {
    fprintf(_coverage_fout, "6401\n");
    fflush(_coverage_fout);
    ___coverage_array[6401] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  lc_function_name = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6402] == 0) {
    {
    fprintf(_coverage_fout, "6402\n");
    fflush(_coverage_fout);
    ___coverage_array[6402] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )key != (unsigned int )((void *)0)),
                             1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6403] == 0) {
    {
    fprintf(_coverage_fout, "6403\n");
    fflush(_coverage_fout);
    ___coverage_array[6403] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6304] == 0) {
      {
      fprintf(_coverage_fout, "6304\n");
      fflush(_coverage_fout);
      ___coverage_array[6304] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    lc_function_name = (char *)key->constant.value.str.val;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6305] == 0) {
      {
      fprintf(_coverage_fout, "6305\n");
      fflush(_coverage_fout);
      ___coverage_array[6305] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash_value = (unsigned long )key->hash_value;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6310] == 0) {
      {
      fprintf(_coverage_fout, "6310\n");
      fflush(_coverage_fout);
      ___coverage_array[6310] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = __builtin_expect((long )(function_name_strlen + 1 > 32768), 0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6311] == 0) {
      {
      fprintf(_coverage_fout, "6311\n");
      fflush(_coverage_fout);
      ___coverage_array[6311] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    use_heap = (unsigned char )tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6312] == 0) {
      {
      fprintf(_coverage_fout, "6312\n");
      fflush(_coverage_fout);
      ___coverage_array[6312] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (use_heap) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6306] == 0) {
        {
        fprintf(_coverage_fout, "6306\n");
        fflush(_coverage_fout);
        ___coverage_array[6306] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = _emalloc((unsigned int )(function_name_strlen + 1));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6307] == 0) {
        {
        fprintf(_coverage_fout, "6307\n");
        fflush(_coverage_fout);
        ___coverage_array[6307] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      lc_function_name = (char *)tmp___0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6308] == 0) {
        {
        fprintf(_coverage_fout, "6308\n");
        fflush(_coverage_fout);
        ___coverage_array[6308] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = __builtin_alloca((unsigned int )(function_name_strlen + 1));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6309] == 0) {
        {
        fprintf(_coverage_fout, "6309\n");
        fflush(_coverage_fout);
        ___coverage_array[6309] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      lc_function_name = (char *)tmp___1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6313] == 0) {
      {
      fprintf(_coverage_fout, "6313\n");
      fflush(_coverage_fout);
      ___coverage_array[6313] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_str_tolower_copy(lc_function_name, function_name_strval,
                          (unsigned int )function_name_strlen);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6314] == 0) {
      {
      fprintf(_coverage_fout, "6314\n");
      fflush(_coverage_fout);
      ___coverage_array[6314] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = zend_hash_func((char const   *)lc_function_name,
                             (unsigned int )(function_name_strlen + 1));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6315] == 0) {
      {
      fprintf(_coverage_fout, "6315\n");
      fflush(_coverage_fout);
      ___coverage_array[6315] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash_value = (unsigned long )tmp___3;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6404] == 0) {
    {
    fprintf(_coverage_fout, "6404\n");
    fflush(_coverage_fout);
    ___coverage_array[6404] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((zend_uint )function_name_strlen == ce->name_length) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6327] == 0) {
      {
      fprintf(_coverage_fout, "6327\n");
      fflush(_coverage_fout);
      ___coverage_array[6327] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (ce->constructor) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6321] == 0) {
        {
        fprintf(_coverage_fout, "6321\n");
        fflush(_coverage_fout);
        ___coverage_array[6321] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = zend_str_tolower_dup(ce->name, ce->name_length);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6322] == 0) {
        {
        fprintf(_coverage_fout, "6322\n");
        fflush(_coverage_fout);
        ___coverage_array[6322] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      lc_class_name = (char *)tmp___5;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6323] == 0) {
        {
        fprintf(_coverage_fout, "6323\n");
        fflush(_coverage_fout);
        ___coverage_array[6323] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = memcmp((void const   *)lc_class_name,
                       (void const   *)lc_function_name,
                       (unsigned int )function_name_strlen);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6324] == 0) {
        {
        fprintf(_coverage_fout, "6324\n");
        fflush(_coverage_fout);
        ___coverage_array[6324] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___6) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6316] == 0) {
          {
          fprintf(_coverage_fout, "6316\n");
          fflush(_coverage_fout);
          ___coverage_array[6316] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6319] == 0) {
          {
          fprintf(_coverage_fout, "6319\n");
          fflush(_coverage_fout);
          ___coverage_array[6319] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___7 = memcmp((void const   *)(ce->constructor)->common.function_name,
                         (void const   *)"__", sizeof("__") - 1U);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6320] == 0) {
          {
          fprintf(_coverage_fout, "6320\n");
          fflush(_coverage_fout);
          ___coverage_array[6320] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___7) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6317] == 0) {
            {
            fprintf(_coverage_fout, "6317\n");
            fflush(_coverage_fout);
            ___coverage_array[6317] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          fbc = ce->constructor;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6318] == 0) {
            {
            fprintf(_coverage_fout, "6318\n");
            fflush(_coverage_fout);
            ___coverage_array[6318] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6325] == 0) {
        {
        fprintf(_coverage_fout, "6325\n");
        fflush(_coverage_fout);
        ___coverage_array[6325] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _efree((void *)lc_class_name);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6326] == 0) {
        {
        fprintf(_coverage_fout, "6326\n");
        fflush(_coverage_fout);
        ___coverage_array[6326] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6328] == 0) {
      {
      fprintf(_coverage_fout, "6328\n");
      fflush(_coverage_fout);
      ___coverage_array[6328] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6405] == 0) {
    {
    fprintf(_coverage_fout, "6405\n");
    fflush(_coverage_fout);
    ___coverage_array[6405] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___14 = __builtin_expect((long )(! fbc), 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6406] == 0) {
    {
    fprintf(_coverage_fout, "6406\n");
    fflush(_coverage_fout);
    ___coverage_array[6406] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___14) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6350] == 0) {
      {
      fprintf(_coverage_fout, "6350\n");
      fflush(_coverage_fout);
      ___coverage_array[6350] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___15 = zend_hash_quick_find((HashTable const   *)(& ce->function_table),
                                    (char const   *)lc_function_name,
                                    (unsigned int )(function_name_strlen + 1),
                                    hash_value, (void **)(& fbc));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6351] == 0) {
      {
      fprintf(_coverage_fout, "6351\n");
      fflush(_coverage_fout);
      ___coverage_array[6351] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___16 = __builtin_expect((long )(tmp___15 == (int __attribute__((__visibility__("default")))  )-1),
                                0L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6352] == 0) {
      {
      fprintf(_coverage_fout, "6352\n");
      fflush(_coverage_fout);
      ___coverage_array[6352] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___16) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6346] == 0) {
        {
        fprintf(_coverage_fout, "6346\n");
        fflush(_coverage_fout);
        ___coverage_array[6346] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___9 = __builtin_expect((long )(! key), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6347] == 0) {
        {
        fprintf(_coverage_fout, "6347\n");
        fflush(_coverage_fout);
        ___coverage_array[6347] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___9) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6333] == 0) {
          {
          fprintf(_coverage_fout, "6333\n");
          fflush(_coverage_fout);
          ___coverage_array[6333] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6331] == 0) {
            {
            fprintf(_coverage_fout, "6331\n");
            fflush(_coverage_fout);
            ___coverage_array[6331] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = __builtin_expect((long )use_heap, 0L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6332] == 0) {
            {
            fprintf(_coverage_fout, "6332\n");
            fflush(_coverage_fout);
            ___coverage_array[6332] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___8) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6329] == 0) {
              {
              fprintf(_coverage_fout, "6329\n");
              fflush(_coverage_fout);
              ___coverage_array[6329] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _efree((void *)lc_function_name);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6330] == 0) {
              {
              fprintf(_coverage_fout, "6330\n");
              fflush(_coverage_fout);
              ___coverage_array[6330] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          break;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6334] == 0) {
          {
          fprintf(_coverage_fout, "6334\n");
          fflush(_coverage_fout);
          ___coverage_array[6334] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6348] == 0) {
        {
        fprintf(_coverage_fout, "6348\n");
        fflush(_coverage_fout);
        ___coverage_array[6348] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (ce->__call) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6341] == 0) {
          {
          fprintf(_coverage_fout, "6341\n");
          fflush(_coverage_fout);
          ___coverage_array[6341] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (executor_globals.This) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6340] == 0) {
            {
            fprintf(_coverage_fout, "6340\n");
            fflush(_coverage_fout);
            ___coverage_array[6340] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (((executor_globals.This)->value.obj.handlers)->get_class_entry) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6337] == 0) {
              {
              fprintf(_coverage_fout, "6337\n");
              fflush(_coverage_fout);
              ___coverage_array[6337] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___12 = zend_get_class_entry((zval const   *)executor_globals.This);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6338] == 0) {
              {
              fprintf(_coverage_fout, "6338\n");
              fflush(_coverage_fout);
              ___coverage_array[6338] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___13 = instanceof_function((zend_class_entry const   *)tmp___12,
                                           (zend_class_entry const   *)ce);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6339] == 0) {
              {
              fprintf(_coverage_fout, "6339\n");
              fflush(_coverage_fout);
              ___coverage_array[6339] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp___13) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6335] == 0) {
                {
                fprintf(_coverage_fout, "6335\n");
                fflush(_coverage_fout);
                ___coverage_array[6335] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___10 = zend_get_user_call_function(ce, function_name_strval,
                                                     function_name_strlen);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6336] == 0) {
                {
                fprintf(_coverage_fout, "6336\n");
                fflush(_coverage_fout);
                ___coverage_array[6336] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              return ((union _zend_function  __attribute__((__visibility__("default"))) *)tmp___10);
            } else {
              goto _L___1;
            }
          } else {
            goto _L___1;
          }
        } else {
          goto _L___1;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6345] == 0) {
          {
          fprintf(_coverage_fout, "6345\n");
          fflush(_coverage_fout);
          ___coverage_array[6345] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _L___1: /* CIL Label */ 
        _L___0: /* CIL Label */ 
        _L: /* CIL Label */ 
        if (ce->__callstatic) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6342] == 0) {
            {
            fprintf(_coverage_fout, "6342\n");
            fflush(_coverage_fout);
            ___coverage_array[6342] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___11 = zend_get_user_callstatic_function(ce, function_name_strval,
                                                       function_name_strlen);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6343] == 0) {
            {
            fprintf(_coverage_fout, "6343\n");
            fflush(_coverage_fout);
            ___coverage_array[6343] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((union _zend_function  __attribute__((__visibility__("default"))) *)tmp___11);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6344] == 0) {
            {
            fprintf(_coverage_fout, "6344\n");
            fflush(_coverage_fout);
            ___coverage_array[6344] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((union _zend_function  __attribute__((__visibility__("default"))) *)((void *)0));
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6349] == 0) {
        {
        fprintf(_coverage_fout, "6349\n");
        fflush(_coverage_fout);
        ___coverage_array[6349] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6353] == 0) {
      {
      fprintf(_coverage_fout, "6353\n");
      fflush(_coverage_fout);
      ___coverage_array[6353] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6407] == 0) {
    {
    fprintf(_coverage_fout, "6407\n");
    fflush(_coverage_fout);
    ___coverage_array[6407] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (fbc->op_array.fn_flags & 256U) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6354] == 0) {
      {
      fprintf(_coverage_fout, "6354\n");
      fflush(_coverage_fout);
      ___coverage_array[6354] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6393] == 0) {
      {
      fprintf(_coverage_fout, "6393\n");
      fflush(_coverage_fout);
      ___coverage_array[6393] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (fbc->op_array.fn_flags & 1024U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6368] == 0) {
        {
        fprintf(_coverage_fout, "6368\n");
        fflush(_coverage_fout);
        ___coverage_array[6368] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      updated_fbc = zend_check_private_int(fbc, executor_globals.scope,
                                           lc_function_name,
                                           function_name_strlen, hash_value);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6369] == 0) {
        {
        fprintf(_coverage_fout, "6369\n");
        fflush(_coverage_fout);
        ___coverage_array[6369] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___20 = __builtin_expect((long )((unsigned int )updated_fbc != (unsigned int )((void *)0)),
                                  1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6370] == 0) {
        {
        fprintf(_coverage_fout, "6370\n");
        fflush(_coverage_fout);
        ___coverage_array[6370] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___20) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6355] == 0) {
          {
          fprintf(_coverage_fout, "6355\n");
          fflush(_coverage_fout);
          ___coverage_array[6355] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        fbc = updated_fbc;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6367] == 0) {
          {
          fprintf(_coverage_fout, "6367\n");
          fflush(_coverage_fout);
          ___coverage_array[6367] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (ce->__callstatic) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6356] == 0) {
            {
            fprintf(_coverage_fout, "6356\n");
            fflush(_coverage_fout);
            ___coverage_array[6356] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          fbc = zend_get_user_callstatic_function(ce, function_name_strval,
                                                  function_name_strlen);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6363] == 0) {
            {
            fprintf(_coverage_fout, "6363\n");
            fflush(_coverage_fout);
            ___coverage_array[6363] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (executor_globals.scope) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6357] == 0) {
              {
              fprintf(_coverage_fout, "6357\n");
              fflush(_coverage_fout);
              ___coverage_array[6357] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___17 = (executor_globals.scope)->name;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6358] == 0) {
              {
              fprintf(_coverage_fout, "6358\n");
              fflush(_coverage_fout);
              ___coverage_array[6358] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___17 = "";
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6364] == 0) {
            {
            fprintf(_coverage_fout, "6364\n");
            fflush(_coverage_fout);
            ___coverage_array[6364] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (fbc) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6361] == 0) {
              {
              fprintf(_coverage_fout, "6361\n");
              fflush(_coverage_fout);
              ___coverage_array[6361] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (fbc->common.scope) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6359] == 0) {
                {
                fprintf(_coverage_fout, "6359\n");
                fflush(_coverage_fout);
                ___coverage_array[6359] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___18 = (fbc->common.scope)->name;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6360] == 0) {
                {
                fprintf(_coverage_fout, "6360\n");
                fflush(_coverage_fout);
                ___coverage_array[6360] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___18 = "";
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6362] == 0) {
              {
              fprintf(_coverage_fout, "6362\n");
              fflush(_coverage_fout);
              ___coverage_array[6362] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___18 = "";
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6365] == 0) {
            {
            fprintf(_coverage_fout, "6365\n");
            fflush(_coverage_fout);
            ___coverage_array[6365] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___19 = zend_visibility_string(fbc->common.fn_flags);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6366] == 0) {
            {
            fprintf(_coverage_fout, "6366\n");
            fflush(_coverage_fout);
            ___coverage_array[6366] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1,
                              "Call to %s method %s::%s() from context \'%s\'",
                              tmp___19, tmp___18, function_name_strval, tmp___17);
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6392] == 0) {
        {
        fprintf(_coverage_fout, "6392\n");
        fflush(_coverage_fout);
        ___coverage_array[6392] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (fbc->common.fn_flags & 512U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6386] == 0) {
          {
          fprintf(_coverage_fout, "6386\n");
          fflush(_coverage_fout);
          ___coverage_array[6386] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___24 = zend_get_function_root_class(fbc);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6387] == 0) {
          {
          fprintf(_coverage_fout, "6387\n");
          fflush(_coverage_fout);
          ___coverage_array[6387] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___25 = zend_check_protected(tmp___24, executor_globals.scope);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6388] == 0) {
          {
          fprintf(_coverage_fout, "6388\n");
          fflush(_coverage_fout);
          ___coverage_array[6388] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___25) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6371] == 0) {
            {
            fprintf(_coverage_fout, "6371\n");
            fflush(_coverage_fout);
            ___coverage_array[6371] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___26 = 0;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6372] == 0) {
            {
            fprintf(_coverage_fout, "6372\n");
            fflush(_coverage_fout);
            ___coverage_array[6372] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___26 = 1;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6389] == 0) {
          {
          fprintf(_coverage_fout, "6389\n");
          fflush(_coverage_fout);
          ___coverage_array[6389] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___27 = __builtin_expect((long )tmp___26, 0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6390] == 0) {
          {
          fprintf(_coverage_fout, "6390\n");
          fflush(_coverage_fout);
          ___coverage_array[6390] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___27) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6384] == 0) {
            {
            fprintf(_coverage_fout, "6384\n");
            fflush(_coverage_fout);
            ___coverage_array[6384] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (ce->__callstatic) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6373] == 0) {
              {
              fprintf(_coverage_fout, "6373\n");
              fflush(_coverage_fout);
              ___coverage_array[6373] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            fbc = zend_get_user_callstatic_function(ce, function_name_strval,
                                                    function_name_strlen);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6380] == 0) {
              {
              fprintf(_coverage_fout, "6380\n");
              fflush(_coverage_fout);
              ___coverage_array[6380] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (executor_globals.scope) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6374] == 0) {
                {
                fprintf(_coverage_fout, "6374\n");
                fflush(_coverage_fout);
                ___coverage_array[6374] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___21 = (executor_globals.scope)->name;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6375] == 0) {
                {
                fprintf(_coverage_fout, "6375\n");
                fflush(_coverage_fout);
                ___coverage_array[6375] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___21 = "";
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6381] == 0) {
              {
              fprintf(_coverage_fout, "6381\n");
              fflush(_coverage_fout);
              ___coverage_array[6381] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (fbc) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6378] == 0) {
                {
                fprintf(_coverage_fout, "6378\n");
                fflush(_coverage_fout);
                ___coverage_array[6378] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (fbc->common.scope) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6376] == 0) {
                  {
                  fprintf(_coverage_fout, "6376\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6376] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___22 = (fbc->common.scope)->name;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6377] == 0) {
                  {
                  fprintf(_coverage_fout, "6377\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6377] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___22 = "";
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6379] == 0) {
                {
                fprintf(_coverage_fout, "6379\n");
                fflush(_coverage_fout);
                ___coverage_array[6379] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___22 = "";
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6382] == 0) {
              {
              fprintf(_coverage_fout, "6382\n");
              fflush(_coverage_fout);
              ___coverage_array[6382] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___23 = zend_visibility_string(fbc->common.fn_flags);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6383] == 0) {
              {
              fprintf(_coverage_fout, "6383\n");
              fflush(_coverage_fout);
              ___coverage_array[6383] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            zend_error_noreturn(1,
                                "Call to %s method %s::%s() from context \'%s\'",
                                tmp___23, tmp___22, function_name_strval,
                                tmp___21);
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6385] == 0) {
            {
            fprintf(_coverage_fout, "6385\n");
            fflush(_coverage_fout);
            ___coverage_array[6385] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6391] == 0) {
          {
          fprintf(_coverage_fout, "6391\n");
          fflush(_coverage_fout);
          ___coverage_array[6391] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6408] == 0) {
    {
    fprintf(_coverage_fout, "6408\n");
    fflush(_coverage_fout);
    ___coverage_array[6408] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___29 = __builtin_expect((long )(! key), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6409] == 0) {
    {
    fprintf(_coverage_fout, "6409\n");
    fflush(_coverage_fout);
    ___coverage_array[6409] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___29) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6398] == 0) {
      {
      fprintf(_coverage_fout, "6398\n");
      fflush(_coverage_fout);
      ___coverage_array[6398] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6396] == 0) {
        {
        fprintf(_coverage_fout, "6396\n");
        fflush(_coverage_fout);
        ___coverage_array[6396] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___28 = __builtin_expect((long )use_heap, 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6397] == 0) {
        {
        fprintf(_coverage_fout, "6397\n");
        fflush(_coverage_fout);
        ___coverage_array[6397] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___28) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6394] == 0) {
          {
          fprintf(_coverage_fout, "6394\n");
          fflush(_coverage_fout);
          ___coverage_array[6394] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _efree((void *)lc_function_name);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6395] == 0) {
          {
          fprintf(_coverage_fout, "6395\n");
          fflush(_coverage_fout);
          ___coverage_array[6395] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6399] == 0) {
      {
      fprintf(_coverage_fout, "6399\n");
      fflush(_coverage_fout);
      ___coverage_array[6399] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6410] == 0) {
    {
    fprintf(_coverage_fout, "6410\n");
    fflush(_coverage_fout);
    ___coverage_array[6410] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((union _zend_function  __attribute__((__visibility__("default"))) *)fbc);
}
}
zval __attribute__((__visibility__("default")))  **zend_std_get_static_property(zend_class_entry *ce ,
                                                                                char const   *property_name ,
                                                                                int property_name_len ,
                                                                                zend_bool silent ,
                                                                                struct _zend_literal  const  *key ) 
{ zend_property_info *property_info ;
  ulong hash_value ;
  ulong __attribute__((__visibility__("default")))  tmp ;
  long tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  long tmp___2 ;
  char *tmp___3 ;
  int tmp___4 ;
  int tmp___5 ;
  long tmp___6 ;
  long tmp___7 ;
  long tmp___8 ;
  long tmp___9 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6455] == 0) {
    {
    fprintf(_coverage_fout, "6455\n");
    fflush(_coverage_fout);
    ___coverage_array[6455] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___9 = __builtin_expect((long )(! key), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6456] == 0) {
    {
    fprintf(_coverage_fout, "6456\n");
    fflush(_coverage_fout);
    ___coverage_array[6456] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___9) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6453] == 0) {
      {
      fprintf(_coverage_fout, "6453\n");
      fflush(_coverage_fout);
      ___coverage_array[6453] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )*((executor_globals.active_op_array)->run_time_cache + key->cache_slot) == (unsigned int )ce) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6411] == 0) {
        {
        fprintf(_coverage_fout, "6411\n");
        fflush(_coverage_fout);
        ___coverage_array[6411] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      property_info = (zend_property_info *)*((executor_globals.active_op_array)->run_time_cache + (key->cache_slot + 1U));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6412] == 0) {
        {
        fprintf(_coverage_fout, "6412\n");
        fflush(_coverage_fout);
        ___coverage_array[6412] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      property_info = (zend_property_info *)((void *)0);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6454] == 0) {
      {
      fprintf(_coverage_fout, "6454\n");
      fflush(_coverage_fout);
      ___coverage_array[6454] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )property_info == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6438] == 0) {
        {
        fprintf(_coverage_fout, "6438\n");
        fflush(_coverage_fout);
        ___coverage_array[6438] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L: /* CIL Label */ 
      tmp___0 = __builtin_expect((long )((unsigned int )key != (unsigned int )((void *)0)),
                                 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6439] == 0) {
        {
        fprintf(_coverage_fout, "6439\n");
        fflush(_coverage_fout);
        ___coverage_array[6439] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6413] == 0) {
          {
          fprintf(_coverage_fout, "6413\n");
          fflush(_coverage_fout);
          ___coverage_array[6413] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        hash_value = (unsigned long )key->hash_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6414] == 0) {
          {
          fprintf(_coverage_fout, "6414\n");
          fflush(_coverage_fout);
          ___coverage_array[6414] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = zend_hash_func(property_name,
                             (unsigned int )(property_name_len + 1));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6415] == 0) {
          {
          fprintf(_coverage_fout, "6415\n");
          fflush(_coverage_fout);
          ___coverage_array[6415] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        hash_value = (unsigned long )tmp;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6440] == 0) {
        {
        fprintf(_coverage_fout, "6440\n");
        fflush(_coverage_fout);
        ___coverage_array[6440] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = zend_hash_quick_find((HashTable const   *)(& ce->properties_info),
                                     property_name,
                                     (unsigned int )(property_name_len + 1),
                                     hash_value, (void **)(& property_info));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6441] == 0) {
        {
        fprintf(_coverage_fout, "6441\n");
        fflush(_coverage_fout);
        ___coverage_array[6441] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = __builtin_expect((long )(tmp___1 == (int __attribute__((__visibility__("default")))  )-1),
                                 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6442] == 0) {
        {
        fprintf(_coverage_fout, "6442\n");
        fflush(_coverage_fout);
        ___coverage_array[6442] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6418] == 0) {
          {
          fprintf(_coverage_fout, "6418\n");
          fflush(_coverage_fout);
          ___coverage_array[6418] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! silent) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6416] == 0) {
            {
            fprintf(_coverage_fout, "6416\n");
            fflush(_coverage_fout);
            ___coverage_array[6416] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1,
                              "Access to undeclared static property: %s::$%s",
                              ce->name, property_name);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6417] == 0) {
            {
            fprintf(_coverage_fout, "6417\n");
            fflush(_coverage_fout);
            ___coverage_array[6417] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6419] == 0) {
          {
          fprintf(_coverage_fout, "6419\n");
          fflush(_coverage_fout);
          ___coverage_array[6419] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((zval __attribute__((__visibility__("default")))  **)((void *)0));
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6420] == 0) {
          {
          fprintf(_coverage_fout, "6420\n");
          fflush(_coverage_fout);
          ___coverage_array[6420] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6443] == 0) {
        {
        fprintf(_coverage_fout, "6443\n");
        fflush(_coverage_fout);
        ___coverage_array[6443] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = zend_verify_property_access(property_info, ce);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6444] == 0) {
        {
        fprintf(_coverage_fout, "6444\n");
        fflush(_coverage_fout);
        ___coverage_array[6444] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___4) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6421] == 0) {
          {
          fprintf(_coverage_fout, "6421\n");
          fflush(_coverage_fout);
          ___coverage_array[6421] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = 0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6422] == 0) {
          {
          fprintf(_coverage_fout, "6422\n");
          fflush(_coverage_fout);
          ___coverage_array[6422] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = 1;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6445] == 0) {
        {
        fprintf(_coverage_fout, "6445\n");
        fflush(_coverage_fout);
        ___coverage_array[6445] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = __builtin_expect((long )tmp___5, 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6446] == 0) {
        {
        fprintf(_coverage_fout, "6446\n");
        fflush(_coverage_fout);
        ___coverage_array[6446] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___6) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6426] == 0) {
          {
          fprintf(_coverage_fout, "6426\n");
          fflush(_coverage_fout);
          ___coverage_array[6426] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! silent) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6423] == 0) {
            {
            fprintf(_coverage_fout, "6423\n");
            fflush(_coverage_fout);
            ___coverage_array[6423] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___3 = zend_visibility_string(property_info->flags);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6424] == 0) {
            {
            fprintf(_coverage_fout, "6424\n");
            fflush(_coverage_fout);
            ___coverage_array[6424] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1, "Cannot access %s property %s::$%s", tmp___3,
                              ce->name, property_name);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6425] == 0) {
            {
            fprintf(_coverage_fout, "6425\n");
            fflush(_coverage_fout);
            ___coverage_array[6425] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6427] == 0) {
          {
          fprintf(_coverage_fout, "6427\n");
          fflush(_coverage_fout);
          ___coverage_array[6427] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((zval __attribute__((__visibility__("default")))  **)((void *)0));
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6428] == 0) {
          {
          fprintf(_coverage_fout, "6428\n");
          fflush(_coverage_fout);
          ___coverage_array[6428] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6447] == 0) {
        {
        fprintf(_coverage_fout, "6447\n");
        fflush(_coverage_fout);
        ___coverage_array[6447] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___7 = __builtin_expect((long )((property_info->flags & 1U) == 0U), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6448] == 0) {
        {
        fprintf(_coverage_fout, "6448\n");
        fflush(_coverage_fout);
        ___coverage_array[6448] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___7) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6431] == 0) {
          {
          fprintf(_coverage_fout, "6431\n");
          fflush(_coverage_fout);
          ___coverage_array[6431] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! silent) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6429] == 0) {
            {
            fprintf(_coverage_fout, "6429\n");
            fflush(_coverage_fout);
            ___coverage_array[6429] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1,
                              "Access to undeclared static property: %s::$%s",
                              ce->name, property_name);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6430] == 0) {
            {
            fprintf(_coverage_fout, "6430\n");
            fflush(_coverage_fout);
            ___coverage_array[6430] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6432] == 0) {
          {
          fprintf(_coverage_fout, "6432\n");
          fflush(_coverage_fout);
          ___coverage_array[6432] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((zval __attribute__((__visibility__("default")))  **)((void *)0));
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6433] == 0) {
          {
          fprintf(_coverage_fout, "6433\n");
          fflush(_coverage_fout);
          ___coverage_array[6433] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6449] == 0) {
        {
        fprintf(_coverage_fout, "6449\n");
        fflush(_coverage_fout);
        ___coverage_array[6449] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_update_class_constants(ce);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6450] == 0) {
        {
        fprintf(_coverage_fout, "6450\n");
        fflush(_coverage_fout);
        ___coverage_array[6450] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___8 = __builtin_expect((long )((unsigned int )key != (unsigned int )((void *)0)),
                                 1L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6451] == 0) {
        {
        fprintf(_coverage_fout, "6451\n");
        fflush(_coverage_fout);
        ___coverage_array[6451] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___8) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6436] == 0) {
          {
          fprintf(_coverage_fout, "6436\n");
          fflush(_coverage_fout);
          ___coverage_array[6436] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6434] == 0) {
            {
            fprintf(_coverage_fout, "6434\n");
            fflush(_coverage_fout);
            ___coverage_array[6434] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *((executor_globals.active_op_array)->run_time_cache + key->cache_slot) = (void *)ce;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6435] == 0) {
            {
            fprintf(_coverage_fout, "6435\n");
            fflush(_coverage_fout);
            ___coverage_array[6435] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *((executor_globals.active_op_array)->run_time_cache + (key->cache_slot + 1U)) = (void *)property_info;
          break;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6437] == 0) {
          {
          fprintf(_coverage_fout, "6437\n");
          fflush(_coverage_fout);
          ___coverage_array[6437] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6452] == 0) {
        {
        fprintf(_coverage_fout, "6452\n");
        fflush(_coverage_fout);
        ___coverage_array[6452] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6457] == 0) {
    {
    fprintf(_coverage_fout, "6457\n");
    fflush(_coverage_fout);
    ___coverage_array[6457] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zval __attribute__((__visibility__("default")))  **)(ce->static_members_table + property_info->offset));
}
}
zend_bool __attribute__((__visibility__("default")))  zend_std_unset_static_property(zend_class_entry *ce ,
                                                                                     char const   *property_name ,
                                                                                     int property_name_len ,
                                                                                     struct _zend_literal  const  *key ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6458] == 0) {
    {
    fprintf(_coverage_fout, "6458\n");
    fflush(_coverage_fout);
    ___coverage_array[6458] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_error_noreturn(1, "Attempt to unset static property %s::$%s", ce->name,
                      property_name);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6459] == 0) {
    {
    fprintf(_coverage_fout, "6459\n");
    fflush(_coverage_fout);
    ___coverage_array[6459] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((unsigned char __attribute__((__visibility__("default")))  )0);
}
}
union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_constructor(zval *object ) 
{ zend_object *zobj ;
  zend_function *constructor ;
  long tmp ;
  zend_class_entry *tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6483] == 0) {
    {
    fprintf(_coverage_fout, "6483\n");
    fflush(_coverage_fout);
    ___coverage_array[6483] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6484] == 0) {
    {
    fprintf(_coverage_fout, "6484\n");
    fflush(_coverage_fout);
    ___coverage_array[6484] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  constructor = (zobj->ce)->constructor;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6485] == 0) {
    {
    fprintf(_coverage_fout, "6485\n");
    fflush(_coverage_fout);
    ___coverage_array[6485] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (constructor) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6481] == 0) {
      {
      fprintf(_coverage_fout, "6481\n");
      fflush(_coverage_fout);
      ___coverage_array[6481] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (constructor->op_array.fn_flags & 256U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6460] == 0) {
        {
        fprintf(_coverage_fout, "6460\n");
        fflush(_coverage_fout);
        ___coverage_array[6460] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6480] == 0) {
        {
        fprintf(_coverage_fout, "6480\n");
        fflush(_coverage_fout);
        ___coverage_array[6480] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (constructor->op_array.fn_flags & 1024U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6465] == 0) {
          {
          fprintf(_coverage_fout, "6465\n");
          fflush(_coverage_fout);
          ___coverage_array[6465] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __builtin_expect((long )((unsigned int )constructor->common.scope != (unsigned int )executor_globals.scope),
                               0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6466] == 0) {
          {
          fprintf(_coverage_fout, "6466\n");
          fflush(_coverage_fout);
          ___coverage_array[6466] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6463] == 0) {
            {
            fprintf(_coverage_fout, "6463\n");
            fflush(_coverage_fout);
            ___coverage_array[6463] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (executor_globals.scope) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6461] == 0) {
              {
              fprintf(_coverage_fout, "6461\n");
              fflush(_coverage_fout);
              ___coverage_array[6461] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            zend_error_noreturn(1,
                                "Call to private %s::%s() from context \'%s\'",
                                (constructor->common.scope)->name,
                                constructor->common.function_name,
                                (executor_globals.scope)->name);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6462] == 0) {
              {
              fprintf(_coverage_fout, "6462\n");
              fflush(_coverage_fout);
              ___coverage_array[6462] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            zend_error_noreturn(1,
                                "Call to private %s::%s() from invalid context",
                                (constructor->common.scope)->name,
                                constructor->common.function_name);
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6464] == 0) {
            {
            fprintf(_coverage_fout, "6464\n");
            fflush(_coverage_fout);
            ___coverage_array[6464] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6479] == 0) {
          {
          fprintf(_coverage_fout, "6479\n");
          fflush(_coverage_fout);
          ___coverage_array[6479] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (constructor->common.fn_flags & 512U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6473] == 0) {
            {
            fprintf(_coverage_fout, "6473\n");
            fflush(_coverage_fout);
            ___coverage_array[6473] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___0 = zend_get_function_root_class(constructor);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6474] == 0) {
            {
            fprintf(_coverage_fout, "6474\n");
            fflush(_coverage_fout);
            ___coverage_array[6474] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = zend_check_protected(tmp___0, executor_globals.scope);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6475] == 0) {
            {
            fprintf(_coverage_fout, "6475\n");
            fflush(_coverage_fout);
            ___coverage_array[6475] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6467] == 0) {
              {
              fprintf(_coverage_fout, "6467\n");
              fflush(_coverage_fout);
              ___coverage_array[6467] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___2 = 0;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6468] == 0) {
              {
              fprintf(_coverage_fout, "6468\n");
              fflush(_coverage_fout);
              ___coverage_array[6468] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___2 = 1;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6476] == 0) {
            {
            fprintf(_coverage_fout, "6476\n");
            fflush(_coverage_fout);
            ___coverage_array[6476] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___3 = __builtin_expect((long )tmp___2, 0L);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6477] == 0) {
            {
            fprintf(_coverage_fout, "6477\n");
            fflush(_coverage_fout);
            ___coverage_array[6477] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6471] == 0) {
              {
              fprintf(_coverage_fout, "6471\n");
              fflush(_coverage_fout);
              ___coverage_array[6471] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (executor_globals.scope) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6469] == 0) {
                {
                fprintf(_coverage_fout, "6469\n");
                fflush(_coverage_fout);
                ___coverage_array[6469] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zend_error_noreturn(1,
                                  "Call to protected %s::%s() from context \'%s\'",
                                  (constructor->common.scope)->name,
                                  constructor->common.function_name,
                                  (executor_globals.scope)->name);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6470] == 0) {
                {
                fprintf(_coverage_fout, "6470\n");
                fflush(_coverage_fout);
                ___coverage_array[6470] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zend_error_noreturn(1,
                                  "Call to protected %s::%s() from invalid context",
                                  (constructor->common.scope)->name,
                                  constructor->common.function_name);
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6472] == 0) {
              {
              fprintf(_coverage_fout, "6472\n");
              fflush(_coverage_fout);
              ___coverage_array[6472] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6478] == 0) {
            {
            fprintf(_coverage_fout, "6478\n");
            fflush(_coverage_fout);
            ___coverage_array[6478] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6482] == 0) {
      {
      fprintf(_coverage_fout, "6482\n");
      fflush(_coverage_fout);
      ___coverage_array[6482] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6486] == 0) {
    {
    fprintf(_coverage_fout, "6486\n");
    fflush(_coverage_fout);
    ___coverage_array[6486] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((union _zend_function  __attribute__((__visibility__("default"))) *)constructor);
}
}
extern int zend_compare_symbol_tables_i(HashTable *ht1 , HashTable *ht2 ) ;
static int zend_std_compare_objects(zval *o1 , zval *o2 ) 
{ zend_object *zobj1 ;
  zend_object *zobj2 ;
  int i ;
  zval result ;
  int __attribute__((__visibility__("default")))  tmp ;
  int tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6517] == 0) {
    {
    fprintf(_coverage_fout, "6517\n");
    fflush(_coverage_fout);
    ___coverage_array[6517] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj1 = (zend_object *)(executor_globals.objects_store.object_buckets + o1->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6518] == 0) {
    {
    fprintf(_coverage_fout, "6518\n");
    fflush(_coverage_fout);
    ___coverage_array[6518] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj2 = (zend_object *)(executor_globals.objects_store.object_buckets + o2->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6519] == 0) {
    {
    fprintf(_coverage_fout, "6519\n");
    fflush(_coverage_fout);
    ___coverage_array[6519] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )zobj1->ce != (unsigned int )zobj2->ce) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6487] == 0) {
      {
      fprintf(_coverage_fout, "6487\n");
      fflush(_coverage_fout);
      ___coverage_array[6487] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6488] == 0) {
      {
      fprintf(_coverage_fout, "6488\n");
      fflush(_coverage_fout);
      ___coverage_array[6488] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6520] == 0) {
    {
    fprintf(_coverage_fout, "6520\n");
    fflush(_coverage_fout);
    ___coverage_array[6520] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! zobj1->properties) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6508] == 0) {
      {
      fprintf(_coverage_fout, "6508\n");
      fflush(_coverage_fout);
      ___coverage_array[6508] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! zobj2->properties) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6505] == 0) {
        {
        fprintf(_coverage_fout, "6505\n");
        fflush(_coverage_fout);
        ___coverage_array[6505] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      i = 0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6506] == 0) {
        {
        fprintf(_coverage_fout, "6506\n");
        fflush(_coverage_fout);
        ___coverage_array[6506] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6502] == 0) {
          {
          fprintf(_coverage_fout, "6502\n");
          fflush(_coverage_fout);
          ___coverage_array[6502] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (i < (zobj1->ce)->default_properties_count) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6489] == 0) {
            {
            fprintf(_coverage_fout, "6489\n");
            fflush(_coverage_fout);
            ___coverage_array[6489] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6503] == 0) {
          {
          fprintf(_coverage_fout, "6503\n");
          fflush(_coverage_fout);
          ___coverage_array[6503] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (*(zobj1->properties_table + i)) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6498] == 0) {
            {
            fprintf(_coverage_fout, "6498\n");
            fflush(_coverage_fout);
            ___coverage_array[6498] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (*(zobj2->properties_table + i)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6494] == 0) {
              {
              fprintf(_coverage_fout, "6494\n");
              fflush(_coverage_fout);
              ___coverage_array[6494] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp = compare_function(& result, *(zobj1->properties_table + i),
                                   *(zobj2->properties_table + i));
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6495] == 0) {
              {
              fprintf(_coverage_fout, "6495\n");
              fflush(_coverage_fout);
              ___coverage_array[6495] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6490] == 0) {
                {
                fprintf(_coverage_fout, "6490\n");
                fflush(_coverage_fout);
                ___coverage_array[6490] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              return (1);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6491] == 0) {
                {
                fprintf(_coverage_fout, "6491\n");
                fflush(_coverage_fout);
                ___coverage_array[6491] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6496] == 0) {
              {
              fprintf(_coverage_fout, "6496\n");
              fflush(_coverage_fout);
              ___coverage_array[6496] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (result.value.lval != 0L) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6492] == 0) {
                {
                fprintf(_coverage_fout, "6492\n");
                fflush(_coverage_fout);
                ___coverage_array[6492] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              return ((int )result.value.lval);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6493] == 0) {
                {
                fprintf(_coverage_fout, "6493\n");
                fflush(_coverage_fout);
                ___coverage_array[6493] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6497] == 0) {
              {
              fprintf(_coverage_fout, "6497\n");
              fflush(_coverage_fout);
              ___coverage_array[6497] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return (1);
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6501] == 0) {
            {
            fprintf(_coverage_fout, "6501\n");
            fflush(_coverage_fout);
            ___coverage_array[6501] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (*(zobj2->properties_table + i)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6499] == 0) {
              {
              fprintf(_coverage_fout, "6499\n");
              fflush(_coverage_fout);
              ___coverage_array[6499] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return (1);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6500] == 0) {
              {
              fprintf(_coverage_fout, "6500\n");
              fflush(_coverage_fout);
              ___coverage_array[6500] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return (0);
          }
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6504] == 0) {
          {
          fprintf(_coverage_fout, "6504\n");
          fflush(_coverage_fout);
          ___coverage_array[6504] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        i ++;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6507] == 0) {
        {
        fprintf(_coverage_fout, "6507\n");
        fflush(_coverage_fout);
        ___coverage_array[6507] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (0);
    } else {
      goto _L;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6513] == 0) {
      {
      fprintf(_coverage_fout, "6513\n");
      fflush(_coverage_fout);
      ___coverage_array[6513] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L: /* CIL Label */ 
    if (! zobj1->properties) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6509] == 0) {
        {
        fprintf(_coverage_fout, "6509\n");
        fflush(_coverage_fout);
        ___coverage_array[6509] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      rebuild_object_properties(zobj1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6510] == 0) {
        {
        fprintf(_coverage_fout, "6510\n");
        fflush(_coverage_fout);
        ___coverage_array[6510] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6514] == 0) {
      {
      fprintf(_coverage_fout, "6514\n");
      fflush(_coverage_fout);
      ___coverage_array[6514] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! zobj2->properties) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6511] == 0) {
        {
        fprintf(_coverage_fout, "6511\n");
        fflush(_coverage_fout);
        ___coverage_array[6511] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      rebuild_object_properties(zobj2);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6512] == 0) {
        {
        fprintf(_coverage_fout, "6512\n");
        fflush(_coverage_fout);
        ___coverage_array[6512] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6515] == 0) {
      {
      fprintf(_coverage_fout, "6515\n");
      fflush(_coverage_fout);
      ___coverage_array[6515] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = zend_compare_symbol_tables_i(zobj1->properties, zobj2->properties);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6516] == 0) {
      {
      fprintf(_coverage_fout, "6516\n");
      fflush(_coverage_fout);
      ___coverage_array[6516] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (tmp___0);
  }
}
}
static int zend_std_has_property(zval *object , zval *member ,
                                 int has_set_exists , zend_literal const   *key ) 
{ zend_object *zobj ;
  int result ;
  zval **value ;
  zval *tmp_member ;
  zend_property_info *property_info ;
  void __attribute__((__visibility__("default")))  *tmp ;
  long tmp___0 ;
  zend_guard *guard ;
  zval *rv ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_uint tmp___2 ;
  zend_bool tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  long tmp___5 ;
  int tmp___6 ;
  int __attribute__((__visibility__("default")))  tmp___7 ;
  long tmp___8 ;
  long tmp___9 ;
  int tmp___10 ;
  long tmp___11 ;
  int __attribute__((__visibility__("default")))  tmp___12 ;
  long tmp___13 ;
  int tmp___14 ;
  int tmp___15 ;
  long tmp___16 ;
  long tmp___17 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6619] == 0) {
    {
    fprintf(_coverage_fout, "6619\n");
    fflush(_coverage_fout);
    ___coverage_array[6619] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  value = (zval **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6620] == 0) {
    {
    fprintf(_coverage_fout, "6620\n");
    fflush(_coverage_fout);
    ___coverage_array[6620] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp_member = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6621] == 0) {
    {
    fprintf(_coverage_fout, "6621\n");
    fflush(_coverage_fout);
    ___coverage_array[6621] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6622] == 0) {
    {
    fprintf(_coverage_fout, "6622\n");
    fflush(_coverage_fout);
    ___coverage_array[6622] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = __builtin_expect((long )((int )member->type != 6), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6623] == 0) {
    {
    fprintf(_coverage_fout, "6623\n");
    fflush(_coverage_fout);
    ___coverage_array[6623] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6526] == 0) {
      {
      fprintf(_coverage_fout, "6526\n");
      fflush(_coverage_fout);
      ___coverage_array[6526] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6521] == 0) {
        {
        fprintf(_coverage_fout, "6521\n");
        fflush(_coverage_fout);
        ___coverage_array[6521] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6522] == 0) {
        {
        fprintf(_coverage_fout, "6522\n");
        fflush(_coverage_fout);
        ___coverage_array[6522] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp_member = (zval *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6523] == 0) {
        {
        fprintf(_coverage_fout, "6523\n");
        fflush(_coverage_fout);
        ___coverage_array[6523] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)tmp_member)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6527] == 0) {
      {
      fprintf(_coverage_fout, "6527\n");
      fflush(_coverage_fout);
      ___coverage_array[6527] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6528] == 0) {
      {
      fprintf(_coverage_fout, "6528\n");
      fflush(_coverage_fout);
      ___coverage_array[6528] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6529] == 0) {
      {
      fprintf(_coverage_fout, "6529\n");
      fflush(_coverage_fout);
      ___coverage_array[6529] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6530] == 0) {
      {
      fprintf(_coverage_fout, "6530\n");
      fflush(_coverage_fout);
      ___coverage_array[6530] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6531] == 0) {
      {
      fprintf(_coverage_fout, "6531\n");
      fflush(_coverage_fout);
      ___coverage_array[6531] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )tmp_member->type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6524] == 0) {
        {
        fprintf(_coverage_fout, "6524\n");
        fflush(_coverage_fout);
        ___coverage_array[6524] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6525] == 0) {
        {
        fprintf(_coverage_fout, "6525\n");
        fflush(_coverage_fout);
        ___coverage_array[6525] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6532] == 0) {
      {
      fprintf(_coverage_fout, "6532\n");
      fflush(_coverage_fout);
      ___coverage_array[6532] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = tmp_member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6533] == 0) {
      {
      fprintf(_coverage_fout, "6533\n");
      fflush(_coverage_fout);
      ___coverage_array[6533] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    key = (zend_literal const   *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6534] == 0) {
      {
      fprintf(_coverage_fout, "6534\n");
      fflush(_coverage_fout);
      ___coverage_array[6534] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6624] == 0) {
    {
    fprintf(_coverage_fout, "6624\n");
    fflush(_coverage_fout);
    ___coverage_array[6624] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  property_info = zend_get_property_info_quick(zobj->ce, member, 1, key);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6625] == 0) {
    {
    fprintf(_coverage_fout, "6625\n");
    fflush(_coverage_fout);
    ___coverage_array[6625] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___8 = __builtin_expect((long )(! property_info), 0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6626] == 0) {
    {
    fprintf(_coverage_fout, "6626\n");
    fflush(_coverage_fout);
    ___coverage_array[6626] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___8) {
    goto _L___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6614] == 0) {
      {
      fprintf(_coverage_fout, "6614\n");
      fflush(_coverage_fout);
      ___coverage_array[6614] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___16 = __builtin_expect((long )((property_info->flags & 1U) == 0U), 1L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6615] == 0) {
      {
      fprintf(_coverage_fout, "6615\n");
      fflush(_coverage_fout);
      ___coverage_array[6615] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___16) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6541] == 0) {
        {
        fprintf(_coverage_fout, "6541\n");
        fflush(_coverage_fout);
        ___coverage_array[6541] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (property_info->offset >= 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6539] == 0) {
          {
          fprintf(_coverage_fout, "6539\n");
          fflush(_coverage_fout);
          ___coverage_array[6539] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (zobj->properties) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6535] == 0) {
            {
            fprintf(_coverage_fout, "6535\n");
            fflush(_coverage_fout);
            ___coverage_array[6535] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          value = (zval **)*(zobj->properties_table + property_info->offset);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6536] == 0) {
            {
            fprintf(_coverage_fout, "6536\n");
            fflush(_coverage_fout);
            ___coverage_array[6536] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = (unsigned int )value == (unsigned int )((void *)0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6537] == 0) {
            {
            fprintf(_coverage_fout, "6537\n");
            fflush(_coverage_fout);
            ___coverage_array[6537] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          value = zobj->properties_table + property_info->offset;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6538] == 0) {
            {
            fprintf(_coverage_fout, "6538\n");
            fflush(_coverage_fout);
            ___coverage_array[6538] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = (unsigned int )*value == (unsigned int )((void *)0);
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6540] == 0) {
          {
          fprintf(_coverage_fout, "6540\n");
          fflush(_coverage_fout);
          ___coverage_array[6540] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___15 = tmp___10;
      } else {
        goto _L;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6548] == 0) {
        {
        fprintf(_coverage_fout, "6548\n");
        fflush(_coverage_fout);
        ___coverage_array[6548] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L: /* CIL Label */ 
      tmp___11 = __builtin_expect((long )(! zobj->properties), 0L);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6549] == 0) {
        {
        fprintf(_coverage_fout, "6549\n");
        fflush(_coverage_fout);
        ___coverage_array[6549] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___11) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6542] == 0) {
          {
          fprintf(_coverage_fout, "6542\n");
          fflush(_coverage_fout);
          ___coverage_array[6542] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___14 = 1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6545] == 0) {
          {
          fprintf(_coverage_fout, "6545\n");
          fflush(_coverage_fout);
          ___coverage_array[6545] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___12 = zend_hash_quick_find((HashTable const   *)zobj->properties,
                                        property_info->name,
                                        (unsigned int )(property_info->name_length + 1),
                                        property_info->h, (void **)(& value));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6546] == 0) {
          {
          fprintf(_coverage_fout, "6546\n");
          fflush(_coverage_fout);
          ___coverage_array[6546] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___13 = __builtin_expect((long )(tmp___12 == (int __attribute__((__visibility__("default")))  )-1),
                                    0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6547] == 0) {
          {
          fprintf(_coverage_fout, "6547\n");
          fflush(_coverage_fout);
          ___coverage_array[6547] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___13) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6543] == 0) {
            {
            fprintf(_coverage_fout, "6543\n");
            fflush(_coverage_fout);
            ___coverage_array[6543] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___14 = 1;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6544] == 0) {
            {
            fprintf(_coverage_fout, "6544\n");
            fflush(_coverage_fout);
            ___coverage_array[6544] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___14 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6550] == 0) {
        {
        fprintf(_coverage_fout, "6550\n");
        fflush(_coverage_fout);
        ___coverage_array[6550] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___15 = tmp___14;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6616] == 0) {
      {
      fprintf(_coverage_fout, "6616\n");
      fflush(_coverage_fout);
      ___coverage_array[6616] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___15) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6608] == 0) {
        {
        fprintf(_coverage_fout, "6608\n");
        fflush(_coverage_fout);
        ___coverage_array[6608] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L___0: /* CIL Label */ 
      result = 0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6609] == 0) {
        {
        fprintf(_coverage_fout, "6609\n");
        fflush(_coverage_fout);
        ___coverage_array[6609] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (has_set_exists != 2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6606] == 0) {
          {
          fprintf(_coverage_fout, "6606\n");
          fflush(_coverage_fout);
          ___coverage_array[6606] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((zobj->ce)->__isset) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6603] == 0) {
            {
            fprintf(_coverage_fout, "6603\n");
            fflush(_coverage_fout);
            ___coverage_array[6603] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___6 = zend_get_property_guard(zobj, property_info, member, & guard);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6604] == 0) {
            {
            fprintf(_coverage_fout, "6604\n");
            fflush(_coverage_fout);
            ___coverage_array[6604] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___6 == 0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6601] == 0) {
              {
              fprintf(_coverage_fout, "6601\n");
              fflush(_coverage_fout);
              ___coverage_array[6601] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (! guard->in_isset) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6592] == 0) {
                {
                fprintf(_coverage_fout, "6592\n");
                fflush(_coverage_fout);
                ___coverage_array[6592] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              zval_addref_p(object);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6593] == 0) {
                {
                fprintf(_coverage_fout, "6593\n");
                fflush(_coverage_fout);
                ___coverage_array[6593] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___3 = zval_isref_p(object);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6594] == 0) {
                {
                fprintf(_coverage_fout, "6594\n");
                fflush(_coverage_fout);
                ___coverage_array[6594] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (tmp___3) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6567] == 0) {
                  {
                  fprintf(_coverage_fout, "6567\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6567] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                while (1) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[6565] == 0) {
                    {
                    fprintf(_coverage_fout, "6565\n");
                    fflush(_coverage_fout);
                    ___coverage_array[6565] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  tmp___2 = zval_refcount_p(object);
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[6566] == 0) {
                    {
                    fprintf(_coverage_fout, "6566\n");
                    fflush(_coverage_fout);
                    ___coverage_array[6566] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if (tmp___2 > 1U) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6559] == 0) {
                      {
                      fprintf(_coverage_fout, "6559\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6559] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    zval_delref_p(object);
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6560] == 0) {
                      {
                      fprintf(_coverage_fout, "6560\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6560] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    while (1) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6551] == 0) {
                        {
                        fprintf(_coverage_fout, "6551\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6551] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      tmp___1 = _emalloc(sizeof(zval_gc_info ));
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6552] == 0) {
                        {
                        fprintf(_coverage_fout, "6552\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6552] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      new_zv = (zval *)tmp___1;
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6553] == 0) {
                        {
                        fprintf(_coverage_fout, "6553\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6553] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
                      break;
                    }
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6561] == 0) {
                      {
                      fprintf(_coverage_fout, "6561\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6561] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    while (1) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6556] == 0) {
                        {
                        fprintf(_coverage_fout, "6556\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6556] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      while (1) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[6554] == 0) {
                          {
                          fprintf(_coverage_fout, "6554\n");
                          fflush(_coverage_fout);
                          ___coverage_array[6554] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        new_zv->value = object->value;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[6555] == 0) {
                          {
                          fprintf(_coverage_fout, "6555\n");
                          fflush(_coverage_fout);
                          ___coverage_array[6555] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        new_zv->type = object->type;
                        break;
                      }
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6557] == 0) {
                        {
                        fprintf(_coverage_fout, "6557\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6557] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      zval_set_refcount_p(new_zv, 1U);
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6558] == 0) {
                        {
                        fprintf(_coverage_fout, "6558\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6558] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      zval_unset_isref_p(new_zv);
                      break;
                    }
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6562] == 0) {
                      {
                      fprintf(_coverage_fout, "6562\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6562] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    object = new_zv;
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6563] == 0) {
                      {
                      fprintf(_coverage_fout, "6563\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6563] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    _zval_copy_ctor(new_zv);
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6564] == 0) {
                      {
                      fprintf(_coverage_fout, "6564\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6564] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                  break;
                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6568] == 0) {
                  {
                  fprintf(_coverage_fout, "6568\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6568] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6595] == 0) {
                {
                fprintf(_coverage_fout, "6595\n");
                fflush(_coverage_fout);
                ___coverage_array[6595] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              guard->in_isset = (unsigned char)1;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6596] == 0) {
                {
                fprintf(_coverage_fout, "6596\n");
                fflush(_coverage_fout);
                ___coverage_array[6596] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              rv = zend_std_call_issetter(object, member);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6597] == 0) {
                {
                fprintf(_coverage_fout, "6597\n");
                fflush(_coverage_fout);
                ___coverage_array[6597] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (rv) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6587] == 0) {
                  {
                  fprintf(_coverage_fout, "6587\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6587] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___4 = zend_is_true(rv);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6588] == 0) {
                  {
                  fprintf(_coverage_fout, "6588\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6588] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                result = (int )tmp___4;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6589] == 0) {
                  {
                  fprintf(_coverage_fout, "6589\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6589] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _zval_ptr_dtor(& rv);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6590] == 0) {
                  {
                  fprintf(_coverage_fout, "6590\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6590] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (has_set_exists) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[6585] == 0) {
                    {
                    fprintf(_coverage_fout, "6585\n");
                    fflush(_coverage_fout);
                    ___coverage_array[6585] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if (result) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6582] == 0) {
                      {
                      fprintf(_coverage_fout, "6582\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6582] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    tmp___5 = __builtin_expect((long )(! executor_globals.exception),
                                               1L);
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6583] == 0) {
                      {
                      fprintf(_coverage_fout, "6583\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6583] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    if (tmp___5) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6580] == 0) {
                        {
                        fprintf(_coverage_fout, "6580\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6580] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if ((zobj->ce)->__get) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[6578] == 0) {
                          {
                          fprintf(_coverage_fout, "6578\n");
                          fflush(_coverage_fout);
                          ___coverage_array[6578] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        if (! guard->in_get) {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[6573] == 0) {
                            {
                            fprintf(_coverage_fout, "6573\n");
                            fflush(_coverage_fout);
                            ___coverage_array[6573] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          guard->in_get = (unsigned char)1;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[6574] == 0) {
                            {
                            fprintf(_coverage_fout, "6574\n");
                            fflush(_coverage_fout);
                            ___coverage_array[6574] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          rv = zend_std_call_getter(object, member);
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[6575] == 0) {
                            {
                            fprintf(_coverage_fout, "6575\n");
                            fflush(_coverage_fout);
                            ___coverage_array[6575] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          guard->in_get = (unsigned char)0;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[6576] == 0) {
                            {
                            fprintf(_coverage_fout, "6576\n");
                            fflush(_coverage_fout);
                            ___coverage_array[6576] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          if (rv) {
                            {
                            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                   "a");
                            if (___coverage_array[6569] == 0) {
                              {
                              fprintf(_coverage_fout, "6569\n");
                              fflush(_coverage_fout);
                              ___coverage_array[6569] = 1;
                              }
                            }
                            fclose(_coverage_fout);
                            }
                            zval_addref_p(rv);
                            {
                            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                   "a");
                            if (___coverage_array[6570] == 0) {
                              {
                              fprintf(_coverage_fout, "6570\n");
                              fflush(_coverage_fout);
                              ___coverage_array[6570] = 1;
                              }
                            }
                            fclose(_coverage_fout);
                            }
                            result = i_zend_is_true(rv);
                            {
                            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                   "a");
                            if (___coverage_array[6571] == 0) {
                              {
                              fprintf(_coverage_fout, "6571\n");
                              fflush(_coverage_fout);
                              ___coverage_array[6571] = 1;
                              }
                            }
                            fclose(_coverage_fout);
                            }
                            _zval_ptr_dtor(& rv);
                          } else {
                            {
                            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                   "a");
                            if (___coverage_array[6572] == 0) {
                              {
                              fprintf(_coverage_fout, "6572\n");
                              fflush(_coverage_fout);
                              ___coverage_array[6572] = 1;
                              }
                            }
                            fclose(_coverage_fout);
                            }
                            result = 0;
                          }
                        } else {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[6577] == 0) {
                            {
                            fprintf(_coverage_fout, "6577\n");
                            fflush(_coverage_fout);
                            ___coverage_array[6577] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          result = 0;
                        }
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[6579] == 0) {
                          {
                          fprintf(_coverage_fout, "6579\n");
                          fflush(_coverage_fout);
                          ___coverage_array[6579] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        result = 0;
                      }
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[6581] == 0) {
                        {
                        fprintf(_coverage_fout, "6581\n");
                        fflush(_coverage_fout);
                        ___coverage_array[6581] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      result = 0;
                    }
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[6584] == 0) {
                      {
                      fprintf(_coverage_fout, "6584\n");
                      fflush(_coverage_fout);
                      ___coverage_array[6584] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[6586] == 0) {
                    {
                    fprintf(_coverage_fout, "6586\n");
                    fflush(_coverage_fout);
                    ___coverage_array[6586] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6591] == 0) {
                  {
                  fprintf(_coverage_fout, "6591\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6591] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6598] == 0) {
                {
                fprintf(_coverage_fout, "6598\n");
                fflush(_coverage_fout);
                ___coverage_array[6598] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              guard->in_isset = (unsigned char)0;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6599] == 0) {
                {
                fprintf(_coverage_fout, "6599\n");
                fflush(_coverage_fout);
                ___coverage_array[6599] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              _zval_ptr_dtor(& object);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6600] == 0) {
                {
                fprintf(_coverage_fout, "6600\n");
                fflush(_coverage_fout);
                ___coverage_array[6600] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6602] == 0) {
              {
              fprintf(_coverage_fout, "6602\n");
              fflush(_coverage_fout);
              ___coverage_array[6602] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6605] == 0) {
            {
            fprintf(_coverage_fout, "6605\n");
            fflush(_coverage_fout);
            ___coverage_array[6605] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6607] == 0) {
          {
          fprintf(_coverage_fout, "6607\n");
          fflush(_coverage_fout);
          ___coverage_array[6607] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      switch (has_set_exists) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6610] == 0) {
        {
        fprintf(_coverage_fout, "6610\n");
        fflush(_coverage_fout);
        ___coverage_array[6610] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 0: 
      result = (int )(*value)->type != 0;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6611] == 0) {
        {
        fprintf(_coverage_fout, "6611\n");
        fflush(_coverage_fout);
        ___coverage_array[6611] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      default: 
      tmp___7 = zend_is_true(*value);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6612] == 0) {
        {
        fprintf(_coverage_fout, "6612\n");
        fflush(_coverage_fout);
        ___coverage_array[6612] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = (int )tmp___7;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6613] == 0) {
        {
        fprintf(_coverage_fout, "6613\n");
        fflush(_coverage_fout);
        ___coverage_array[6613] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 2: 
      result = 1;
      break;
      }
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6627] == 0) {
    {
    fprintf(_coverage_fout, "6627\n");
    fflush(_coverage_fout);
    ___coverage_array[6627] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___17 = __builtin_expect((long )((unsigned int )tmp_member != (unsigned int )((void *)0)),
                              0L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6628] == 0) {
    {
    fprintf(_coverage_fout, "6628\n");
    fflush(_coverage_fout);
    ___coverage_array[6628] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___17) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6617] == 0) {
      {
      fprintf(_coverage_fout, "6617\n");
      fflush(_coverage_fout);
      ___coverage_array[6617] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& tmp_member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6618] == 0) {
      {
      fprintf(_coverage_fout, "6618\n");
      fflush(_coverage_fout);
      ___coverage_array[6618] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6629] == 0) {
    {
    fprintf(_coverage_fout, "6629\n");
    fflush(_coverage_fout);
    ___coverage_array[6629] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (result);
}
}
zend_class_entry *zend_std_object_get_class(zval const   *object ) 
{ zend_object *zobj ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6630] == 0) {
    {
    fprintf(_coverage_fout, "6630\n");
    fflush(_coverage_fout);
    ___coverage_array[6630] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6631] == 0) {
    {
    fprintf(_coverage_fout, "6631\n");
    fflush(_coverage_fout);
    ___coverage_array[6631] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (zobj->ce);
}
}
int zend_std_object_get_class_name(zval const   *object ,
                                   char const   **class_name ,
                                   zend_uint *class_name_len , int parent ) 
{ zend_object *zobj ;
  zend_class_entry *ce ;
  char __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6637] == 0) {
    {
    fprintf(_coverage_fout, "6637\n");
    fflush(_coverage_fout);
    ___coverage_array[6637] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zobj = (zend_object *)(executor_globals.objects_store.object_buckets + object->value.obj.handle)->bucket.obj.object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6638] == 0) {
    {
    fprintf(_coverage_fout, "6638\n");
    fflush(_coverage_fout);
    ___coverage_array[6638] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parent) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6634] == 0) {
      {
      fprintf(_coverage_fout, "6634\n");
      fflush(_coverage_fout);
      ___coverage_array[6634] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! (zobj->ce)->parent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6632] == 0) {
        {
        fprintf(_coverage_fout, "6632\n");
        fflush(_coverage_fout);
        ___coverage_array[6632] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (-1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6633] == 0) {
        {
        fprintf(_coverage_fout, "6633\n");
        fflush(_coverage_fout);
        ___coverage_array[6633] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6635] == 0) {
      {
      fprintf(_coverage_fout, "6635\n");
      fflush(_coverage_fout);
      ___coverage_array[6635] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce = (zobj->ce)->parent;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6636] == 0) {
      {
      fprintf(_coverage_fout, "6636\n");
      fflush(_coverage_fout);
      ___coverage_array[6636] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce = zobj->ce;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6639] == 0) {
    {
    fprintf(_coverage_fout, "6639\n");
    fflush(_coverage_fout);
    ___coverage_array[6639] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *class_name_len = ce->name_length;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6640] == 0) {
    {
    fprintf(_coverage_fout, "6640\n");
    fflush(_coverage_fout);
    ___coverage_array[6640] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _estrndup(ce->name, ce->name_length);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6641] == 0) {
    {
    fprintf(_coverage_fout, "6641\n");
    fflush(_coverage_fout);
    ___coverage_array[6641] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *class_name = (char const   *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6642] == 0) {
    {
    fprintf(_coverage_fout, "6642\n");
    fflush(_coverage_fout);
    ___coverage_array[6642] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
int __attribute__((__visibility__("default")))  zend_std_cast_object_tostring(zval *readobj ,
                                                                              zval *writeobj ,
                                                                              int type ) 
{ zval *retval ;
  zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  long tmp___0 ;
  zend_uchar is_ref ;
  zend_bool tmp___1 ;
  zend_uint refcount ;
  zend_uint tmp___2 ;
  zval *__z ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;
  long tmp___4 ;
  zval __attribute__((__visibility__("default")))  *tmp___5 ;
  zval *__z___0 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___6 ;
  zval *__z___1 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___7 ;
  zval *__z___2 ;

  {
  switch (type) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6709] == 0) {
    {
    fprintf(_coverage_fout, "6709\n");
    fflush(_coverage_fout);
    ___coverage_array[6709] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 6: 
  tmp = zend_get_class_entry((zval const   *)readobj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6710] == 0) {
    {
    fprintf(_coverage_fout, "6710\n");
    fflush(_coverage_fout);
    ___coverage_array[6710] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6711] == 0) {
    {
    fprintf(_coverage_fout, "6711\n");
    fflush(_coverage_fout);
    ___coverage_array[6711] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ce->__tostring) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6699] == 0) {
      {
      fprintf(_coverage_fout, "6699\n");
      fflush(_coverage_fout);
      ___coverage_array[6699] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = zend_call_method(& readobj, ce, & ce->__tostring, "__tostring",
                               (int )(sizeof("__tostring") - 1U), & retval, 0,
                               (zval *)((void *)0), (zval *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6700] == 0) {
      {
      fprintf(_coverage_fout, "6700\n");
      fflush(_coverage_fout);
      ___coverage_array[6700] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___5) {
      goto _L;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6698] == 0) {
        {
        fprintf(_coverage_fout, "6698\n");
        fflush(_coverage_fout);
        ___coverage_array[6698] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (executor_globals.exception) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6693] == 0) {
          {
          fprintf(_coverage_fout, "6693\n");
          fflush(_coverage_fout);
          ___coverage_array[6693] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _L: /* CIL Label */ 
        tmp___0 = __builtin_expect((long )((unsigned int )executor_globals.exception != (unsigned int )((void *)0)),
                                   0L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6694] == 0) {
          {
          fprintf(_coverage_fout, "6694\n");
          fflush(_coverage_fout);
          ___coverage_array[6694] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6645] == 0) {
            {
            fprintf(_coverage_fout, "6645\n");
            fflush(_coverage_fout);
            ___coverage_array[6645] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (retval) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6643] == 0) {
              {
              fprintf(_coverage_fout, "6643\n");
              fflush(_coverage_fout);
              ___coverage_array[6643] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_ptr_dtor(& retval);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6644] == 0) {
              {
              fprintf(_coverage_fout, "6644\n");
              fflush(_coverage_fout);
              ___coverage_array[6644] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6646] == 0) {
            {
            fprintf(_coverage_fout, "6646\n");
            fflush(_coverage_fout);
            ___coverage_array[6646] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error_noreturn(1,
                              "Method %s::__toString() must not throw an exception",
                              ce->name);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6647] == 0) {
            {
            fprintf(_coverage_fout, "6647\n");
            fflush(_coverage_fout);
            ___coverage_array[6647] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((int __attribute__((__visibility__("default")))  )-1);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6648] == 0) {
            {
            fprintf(_coverage_fout, "6648\n");
            fflush(_coverage_fout);
            ___coverage_array[6648] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6695] == 0) {
          {
          fprintf(_coverage_fout, "6695\n");
          fflush(_coverage_fout);
          ___coverage_array[6695] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___4 = __builtin_expect((long )((int )retval->type == 6), 1L);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6696] == 0) {
          {
          fprintf(_coverage_fout, "6696\n");
          fflush(_coverage_fout);
          ___coverage_array[6696] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___4) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6665] == 0) {
            {
            fprintf(_coverage_fout, "6665\n");
            fflush(_coverage_fout);
            ___coverage_array[6665] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          writeobj->refcount__gc = 1U;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6666] == 0) {
            {
            fprintf(_coverage_fout, "6666\n");
            fflush(_coverage_fout);
            ___coverage_array[6666] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          writeobj->is_ref__gc = (unsigned char)0;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6667] == 0) {
            {
            fprintf(_coverage_fout, "6667\n");
            fflush(_coverage_fout);
            ___coverage_array[6667] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )readobj == (unsigned int )writeobj) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6649] == 0) {
              {
              fprintf(_coverage_fout, "6649\n");
              fflush(_coverage_fout);
              ___coverage_array[6649] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_dtor(readobj);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6650] == 0) {
              {
              fprintf(_coverage_fout, "6650\n");
              fflush(_coverage_fout);
              ___coverage_array[6650] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6668] == 0) {
            {
            fprintf(_coverage_fout, "6668\n");
            fflush(_coverage_fout);
            ___coverage_array[6668] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = zval_isref_p(writeobj);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6669] == 0) {
            {
            fprintf(_coverage_fout, "6669\n");
            fflush(_coverage_fout);
            ___coverage_array[6669] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          is_ref = tmp___1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6670] == 0) {
            {
            fprintf(_coverage_fout, "6670\n");
            fflush(_coverage_fout);
            ___coverage_array[6670] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___2 = zval_refcount_p(writeobj);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6671] == 0) {
            {
            fprintf(_coverage_fout, "6671\n");
            fflush(_coverage_fout);
            ___coverage_array[6671] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          refcount = tmp___2;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6672] == 0) {
            {
            fprintf(_coverage_fout, "6672\n");
            fflush(_coverage_fout);
            ___coverage_array[6672] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6651] == 0) {
              {
              fprintf(_coverage_fout, "6651\n");
              fflush(_coverage_fout);
              ___coverage_array[6651] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            writeobj->value = retval->value;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6652] == 0) {
              {
              fprintf(_coverage_fout, "6652\n");
              fflush(_coverage_fout);
              ___coverage_array[6652] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            writeobj->type = retval->type;
            break;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6673] == 0) {
            {
            fprintf(_coverage_fout, "6673\n");
            fflush(_coverage_fout);
            ___coverage_array[6673] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zval_copy_ctor(writeobj);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6674] == 0) {
            {
            fprintf(_coverage_fout, "6674\n");
            fflush(_coverage_fout);
            ___coverage_array[6674] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zval_ptr_dtor(& retval);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6675] == 0) {
            {
            fprintf(_coverage_fout, "6675\n");
            fflush(_coverage_fout);
            ___coverage_array[6675] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_set_isref_to_p(writeobj, is_ref);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6676] == 0) {
            {
            fprintf(_coverage_fout, "6676\n");
            fflush(_coverage_fout);
            ___coverage_array[6676] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zval_set_refcount_p(writeobj, refcount);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6677] == 0) {
            {
            fprintf(_coverage_fout, "6677\n");
            fflush(_coverage_fout);
            ___coverage_array[6677] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int )writeobj->type != type) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6663] == 0) {
              {
              fprintf(_coverage_fout, "6663\n");
              fflush(_coverage_fout);
              ___coverage_array[6663] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            while (1) {
              switch (type) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6655] == 0) {
                {
                fprintf(_coverage_fout, "6655\n");
                fflush(_coverage_fout);
                ___coverage_array[6655] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 0: 
              convert_to_null(writeobj);
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6656] == 0) {
                {
                fprintf(_coverage_fout, "6656\n");
                fflush(_coverage_fout);
                ___coverage_array[6656] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 1: 
              convert_to_long(writeobj);
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6657] == 0) {
                {
                fprintf(_coverage_fout, "6657\n");
                fflush(_coverage_fout);
                ___coverage_array[6657] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 2: 
              convert_to_double(writeobj);
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6658] == 0) {
                {
                fprintf(_coverage_fout, "6658\n");
                fflush(_coverage_fout);
                ___coverage_array[6658] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 3: 
              convert_to_boolean(writeobj);
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6659] == 0) {
                {
                fprintf(_coverage_fout, "6659\n");
                fflush(_coverage_fout);
                ___coverage_array[6659] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 4: 
              convert_to_array(writeobj);
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6660] == 0) {
                {
                fprintf(_coverage_fout, "6660\n");
                fflush(_coverage_fout);
                ___coverage_array[6660] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 5: 
              convert_to_object(writeobj);
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6661] == 0) {
                {
                fprintf(_coverage_fout, "6661\n");
                fflush(_coverage_fout);
                ___coverage_array[6661] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              case 6: 
              if ((int )writeobj->type != 6) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6653] == 0) {
                  {
                  fprintf(_coverage_fout, "6653\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6653] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                _convert_to_string(writeobj);
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                       "a");
                if (___coverage_array[6654] == 0) {
                  {
                  fprintf(_coverage_fout, "6654\n");
                  fflush(_coverage_fout);
                  ___coverage_array[6654] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              break;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                     "a");
              if (___coverage_array[6662] == 0) {
                {
                fprintf(_coverage_fout, "6662\n");
                fflush(_coverage_fout);
                ___coverage_array[6662] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              default: 
              __assert_fail("0",
                            "/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/php/Zend/zend_object_handlers.c",
                            1487U, "zend_std_cast_object_tostring");
              break;
              }
              break;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6664] == 0) {
              {
              fprintf(_coverage_fout, "6664\n");
              fflush(_coverage_fout);
              ___coverage_array[6664] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6678] == 0) {
            {
            fprintf(_coverage_fout, "6678\n");
            fflush(_coverage_fout);
            ___coverage_array[6678] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((int __attribute__((__visibility__("default")))  )0);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6686] == 0) {
            {
            fprintf(_coverage_fout, "6686\n");
            fflush(_coverage_fout);
            ___coverage_array[6686] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _zval_ptr_dtor(& retval);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6687] == 0) {
            {
            fprintf(_coverage_fout, "6687\n");
            fflush(_coverage_fout);
            ___coverage_array[6687] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          writeobj->refcount__gc = 1U;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6688] == 0) {
            {
            fprintf(_coverage_fout, "6688\n");
            fflush(_coverage_fout);
            ___coverage_array[6688] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          writeobj->is_ref__gc = (unsigned char)0;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6689] == 0) {
            {
            fprintf(_coverage_fout, "6689\n");
            fflush(_coverage_fout);
            ___coverage_array[6689] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )readobj == (unsigned int )writeobj) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6679] == 0) {
              {
              fprintf(_coverage_fout, "6679\n");
              fflush(_coverage_fout);
              ___coverage_array[6679] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_dtor(readobj);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6680] == 0) {
              {
              fprintf(_coverage_fout, "6680\n");
              fflush(_coverage_fout);
              ___coverage_array[6680] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6690] == 0) {
            {
            fprintf(_coverage_fout, "6690\n");
            fflush(_coverage_fout);
            ___coverage_array[6690] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6681] == 0) {
              {
              fprintf(_coverage_fout, "6681\n");
              fflush(_coverage_fout);
              ___coverage_array[6681] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __z = writeobj;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6682] == 0) {
              {
              fprintf(_coverage_fout, "6682\n");
              fflush(_coverage_fout);
              ___coverage_array[6682] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __z->value.str.len = 0;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6683] == 0) {
              {
              fprintf(_coverage_fout, "6683\n");
              fflush(_coverage_fout);
              ___coverage_array[6683] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___3 = _estrndup("", sizeof("") - 1U);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6684] == 0) {
              {
              fprintf(_coverage_fout, "6684\n");
              fflush(_coverage_fout);
              ___coverage_array[6684] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __z->value.str.val = (char *)tmp___3;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                   "a");
            if (___coverage_array[6685] == 0) {
              {
              fprintf(_coverage_fout, "6685\n");
              fflush(_coverage_fout);
              ___coverage_array[6685] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __z->type = (unsigned char)6;
            break;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6691] == 0) {
            {
            fprintf(_coverage_fout, "6691\n");
            fflush(_coverage_fout);
            ___coverage_array[6691] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          zend_error(1 << 12L,
                     "Method %s::__toString() must return a string value",
                     ce->name);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                                 "a");
          if (___coverage_array[6692] == 0) {
            {
            fprintf(_coverage_fout, "6692\n");
            fflush(_coverage_fout);
            ___coverage_array[6692] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((int __attribute__((__visibility__("default")))  )0);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                               "a");
        if (___coverage_array[6697] == 0) {
          {
          fprintf(_coverage_fout, "6697\n");
          fflush(_coverage_fout);
          ___coverage_array[6697] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6701] == 0) {
      {
      fprintf(_coverage_fout, "6701\n");
      fflush(_coverage_fout);
      ___coverage_array[6701] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6712] == 0) {
    {
    fprintf(_coverage_fout, "6712\n");
    fflush(_coverage_fout);
    ___coverage_array[6712] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )-1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6713] == 0) {
    {
    fprintf(_coverage_fout, "6713\n");
    fflush(_coverage_fout);
    ___coverage_array[6713] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  writeobj->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6714] == 0) {
    {
    fprintf(_coverage_fout, "6714\n");
    fflush(_coverage_fout);
    ___coverage_array[6714] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6715] == 0) {
    {
    fprintf(_coverage_fout, "6715\n");
    fflush(_coverage_fout);
    ___coverage_array[6715] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6702] == 0) {
      {
      fprintf(_coverage_fout, "6702\n");
      fflush(_coverage_fout);
      ___coverage_array[6702] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0 = writeobj;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6703] == 0) {
      {
      fprintf(_coverage_fout, "6703\n");
      fflush(_coverage_fout);
      ___coverage_array[6703] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.lval = 1L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6704] == 0) {
      {
      fprintf(_coverage_fout, "6704\n");
      fflush(_coverage_fout);
      ___coverage_array[6704] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->type = (unsigned char)3;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6716] == 0) {
    {
    fprintf(_coverage_fout, "6716\n");
    fflush(_coverage_fout);
    ___coverage_array[6716] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6717] == 0) {
    {
    fprintf(_coverage_fout, "6717\n");
    fflush(_coverage_fout);
    ___coverage_array[6717] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___6 = zend_get_class_entry((zval const   *)readobj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6718] == 0) {
    {
    fprintf(_coverage_fout, "6718\n");
    fflush(_coverage_fout);
    ___coverage_array[6718] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp___6;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6719] == 0) {
    {
    fprintf(_coverage_fout, "6719\n");
    fflush(_coverage_fout);
    ___coverage_array[6719] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_error(1 << 3L, "Object of class %s could not be converted to int",
             ce->name);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6720] == 0) {
    {
    fprintf(_coverage_fout, "6720\n");
    fflush(_coverage_fout);
    ___coverage_array[6720] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6721] == 0) {
    {
    fprintf(_coverage_fout, "6721\n");
    fflush(_coverage_fout);
    ___coverage_array[6721] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6722] == 0) {
    {
    fprintf(_coverage_fout, "6722\n");
    fflush(_coverage_fout);
    ___coverage_array[6722] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )readobj == (unsigned int )writeobj) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6705] == 0) {
      {
      fprintf(_coverage_fout, "6705\n");
      fflush(_coverage_fout);
      ___coverage_array[6705] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(readobj);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6706] == 0) {
      {
      fprintf(_coverage_fout, "6706\n");
      fflush(_coverage_fout);
      ___coverage_array[6706] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6723] == 0) {
    {
    fprintf(_coverage_fout, "6723\n");
    fflush(_coverage_fout);
    ___coverage_array[6723] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___1 = writeobj;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6724] == 0) {
    {
    fprintf(_coverage_fout, "6724\n");
    fflush(_coverage_fout);
    ___coverage_array[6724] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___1->value.lval = 1L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6725] == 0) {
    {
    fprintf(_coverage_fout, "6725\n");
    fflush(_coverage_fout);
    ___coverage_array[6725] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___1->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6726] == 0) {
    {
    fprintf(_coverage_fout, "6726\n");
    fflush(_coverage_fout);
    ___coverage_array[6726] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6727] == 0) {
    {
    fprintf(_coverage_fout, "6727\n");
    fflush(_coverage_fout);
    ___coverage_array[6727] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  tmp___7 = zend_get_class_entry((zval const   *)readobj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6728] == 0) {
    {
    fprintf(_coverage_fout, "6728\n");
    fflush(_coverage_fout);
    ___coverage_array[6728] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp___7;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6729] == 0) {
    {
    fprintf(_coverage_fout, "6729\n");
    fflush(_coverage_fout);
    ___coverage_array[6729] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_error(1 << 3L, "Object of class %s could not be converted to double",
             ce->name);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6730] == 0) {
    {
    fprintf(_coverage_fout, "6730\n");
    fflush(_coverage_fout);
    ___coverage_array[6730] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6731] == 0) {
    {
    fprintf(_coverage_fout, "6731\n");
    fflush(_coverage_fout);
    ___coverage_array[6731] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6732] == 0) {
    {
    fprintf(_coverage_fout, "6732\n");
    fflush(_coverage_fout);
    ___coverage_array[6732] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )readobj == (unsigned int )writeobj) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6707] == 0) {
      {
      fprintf(_coverage_fout, "6707\n");
      fflush(_coverage_fout);
      ___coverage_array[6707] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(readobj);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6708] == 0) {
      {
      fprintf(_coverage_fout, "6708\n");
      fflush(_coverage_fout);
      ___coverage_array[6708] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6733] == 0) {
    {
    fprintf(_coverage_fout, "6733\n");
    fflush(_coverage_fout);
    ___coverage_array[6733] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2 = writeobj;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6734] == 0) {
    {
    fprintf(_coverage_fout, "6734\n");
    fflush(_coverage_fout);
    ___coverage_array[6734] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->value.dval = (double )1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6735] == 0) {
    {
    fprintf(_coverage_fout, "6735\n");
    fflush(_coverage_fout);
    ___coverage_array[6735] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->type = (unsigned char)2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6736] == 0) {
    {
    fprintf(_coverage_fout, "6736\n");
    fflush(_coverage_fout);
    ___coverage_array[6736] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6737] == 0) {
    {
    fprintf(_coverage_fout, "6737\n");
    fflush(_coverage_fout);
    ___coverage_array[6737] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  writeobj->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6738] == 0) {
    {
    fprintf(_coverage_fout, "6738\n");
    fflush(_coverage_fout);
    ___coverage_array[6738] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6739] == 0) {
    {
    fprintf(_coverage_fout, "6739\n");
    fflush(_coverage_fout);
    ___coverage_array[6739] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  writeobj->type = (unsigned char)0;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6740] == 0) {
    {
    fprintf(_coverage_fout, "6740\n");
    fflush(_coverage_fout);
    ___coverage_array[6740] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )-1);
}
}
int zend_std_get_closure(zval *obj , zend_class_entry **ce_ptr ,
                         zend_function **fptr_ptr , zval **zobj_ptr ) 
{ zend_class_entry *ce ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6751] == 0) {
    {
    fprintf(_coverage_fout, "6751\n");
    fflush(_coverage_fout);
    ___coverage_array[6751] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )obj->type != 5) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6741] == 0) {
      {
      fprintf(_coverage_fout, "6741\n");
      fflush(_coverage_fout);
      ___coverage_array[6741] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (-1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6742] == 0) {
      {
      fprintf(_coverage_fout, "6742\n");
      fflush(_coverage_fout);
      ___coverage_array[6742] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6752] == 0) {
    {
    fprintf(_coverage_fout, "6752\n");
    fflush(_coverage_fout);
    ___coverage_array[6752] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_get_class_entry((zval const   *)obj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6753] == 0) {
    {
    fprintf(_coverage_fout, "6753\n");
    fflush(_coverage_fout);
    ___coverage_array[6753] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce = (zend_class_entry *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6754] == 0) {
    {
    fprintf(_coverage_fout, "6754\n");
    fflush(_coverage_fout);
    ___coverage_array[6754] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_hash_find((HashTable const   *)(& ce->function_table),
                           "__invoke", sizeof("__invoke"), (void **)fptr_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6755] == 0) {
    {
    fprintf(_coverage_fout, "6755\n");
    fflush(_coverage_fout);
    ___coverage_array[6755] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6743] == 0) {
      {
      fprintf(_coverage_fout, "6743\n");
      fflush(_coverage_fout);
      ___coverage_array[6743] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (-1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6744] == 0) {
      {
      fprintf(_coverage_fout, "6744\n");
      fflush(_coverage_fout);
      ___coverage_array[6744] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6756] == 0) {
    {
    fprintf(_coverage_fout, "6756\n");
    fflush(_coverage_fout);
    ___coverage_array[6756] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *ce_ptr = ce;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6757] == 0) {
    {
    fprintf(_coverage_fout, "6757\n");
    fflush(_coverage_fout);
    ___coverage_array[6757] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((*fptr_ptr)->common.fn_flags & 1U) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6747] == 0) {
      {
      fprintf(_coverage_fout, "6747\n");
      fflush(_coverage_fout);
      ___coverage_array[6747] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (zobj_ptr) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6745] == 0) {
        {
        fprintf(_coverage_fout, "6745\n");
        fflush(_coverage_fout);
        ___coverage_array[6745] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *zobj_ptr = (zval *)((void *)0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6746] == 0) {
        {
        fprintf(_coverage_fout, "6746\n");
        fflush(_coverage_fout);
        ___coverage_array[6746] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                           "a");
    if (___coverage_array[6750] == 0) {
      {
      fprintf(_coverage_fout, "6750\n");
      fflush(_coverage_fout);
      ___coverage_array[6750] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (zobj_ptr) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6748] == 0) {
        {
        fprintf(_coverage_fout, "6748\n");
        fflush(_coverage_fout);
        ___coverage_array[6748] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *zobj_ptr = obj;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                             "a");
      if (___coverage_array[6749] == 0) {
        {
        fprintf(_coverage_fout, "6749\n");
        fflush(_coverage_fout);
        ___coverage_array[6749] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-11-01-735efbdd04-e0f781f496/coverage/coverage.path",
                         "a");
  if (___coverage_array[6758] == 0) {
    {
    fprintf(_coverage_fout, "6758\n");
    fflush(_coverage_fout);
    ___coverage_array[6758] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
struct _zend_object_handlers  __attribute__((__visibility__("default"))) std_object_handlers  = 
     {(void (*)(zval *object ))(& zend_objects_store_add_ref),
    (void (*)(zval *object ))(& zend_objects_store_del_ref),
    (zend_object_value (*)(zval *object ))(& zend_objects_clone_obj),
    & zend_std_read_property,
    (void (*)(zval *object , zval *member ,
              zval *value , struct _zend_literal  const  *key ))(& zend_std_write_property),
    & zend_std_read_dimension, & zend_std_write_dimension,
    & zend_std_get_property_ptr_ptr, (zval *(*)(zval *object ))((void *)0),
    (void (*)(zval **object , zval *value ))((void *)0),
    & zend_std_has_property, & zend_std_unset_property,
    & zend_std_has_dimension, & zend_std_unset_dimension,
    (HashTable *(*)(zval *object ))(& zend_std_get_properties),
    & zend_std_get_method,
    (int (*)(char const   *method , int ht ,
             zval *return_value , zval **return_value_ptr , zval *this_ptr ,
             int return_value_used ))((void *)0),
    (union _zend_function *(*)(zval *object ))(& zend_std_get_constructor),
    & zend_std_object_get_class, & zend_std_object_get_class_name,
    & zend_std_compare_objects,
    (int (*)(zval *readobj , zval *retval ,
             int type ))(& zend_std_cast_object_tostring),
    (int (*)(zval *object , long *count ))((void *)0),
    (HashTable *(*)(zval *object , int *is_temp ))((void *)0),
    & zend_std_get_closure};
