struct _IO_FILE;
struct _IO_FILE *_coverage_fout  ;
char ___coverage_array[5254] ;
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 *filename ;
   uint lineno ;
   char *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 *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 *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 *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 *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 **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 *method , int ht , zval *return_value ,
                      zval **return_value_ptr , zval *this_ptr ,
                      int return_value_used ) ;
   union _zend_function *(*get_constructor)(zval *object ) ;
   zend_class_entry *(*get_class_entry)(zval const   *object ) ;
   int (*get_class_name)(zval const   *object , char **class_name ,
                         zend_uint *class_name_len , int parent ) ;
   int (*compare_objects)(zval *object1 , zval *object2 ) ;
   int (*cast_object)(zval *readobj , zval *retval , int type ) ;
   int (*count_elements)(zval *object , long *count ) ;
   HashTable *(*get_debug_info)(zval *object , int *is_temp ) ;
   int (*get_closure)(zval *obj , zend_class_entry **ce_ptr ,
                      union _zend_function **fptr_ptr , zval **zobj_ptr ) ;
};
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 *method_name ;
   unsigned int mname_len ;
   zend_class_entry *ce ;
   char *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 *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 *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char *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 *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 *data ) ;
   void (*block_interruptions)(void) ;
   void (*unblock_interruptions)(void) ;
   int (*get_configuration_directive)(char const   *name , uint name_length ,
                                      zval *contents ) ;
   void (*ticks_function)(int ticks ) ;
   void (*on_timeout)(int seconds ) ;
   int (*stream_open_function)(char const   *filename ,
                               zend_file_handle *handle ) ;
   int (*vspprintf_function)(char **pbuf , size_t max_len ,
                             char const   *format , va_list ap ) ;
   char *(*getenv_function)(char *name , size_t name_len ) ;
   char *(*resolve_path_function)(char const   *filename , int filename_len ) ;
};
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 );
union __anonunion_u_45 {
   zval *pz ;
   zend_object_handlers *handlers ;
};
struct _gc_root_buffer {
   struct _gc_root_buffer *prev ;
   struct _gc_root_buffer *next ;
   zend_object_handle handle ;
   union __anonunion_u_45 u ;
};
typedef struct _gc_root_buffer gc_root_buffer;
struct _zval_gc_info;
union __anonunion_u_46 {
   gc_root_buffer *buffered ;
   struct _zval_gc_info *next ;
};
struct _zval_gc_info {
   zval z ;
   union __anonunion_u_46 u ;
};
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_47 {
    EH_NORMAL = 0,
    EH_SUPPRESS = 1,
    EH_THROW = 2
} ;
typedef enum __anonenum_zend_error_handling_t_47 zend_error_handling_t;
struct __anonstruct_zend_error_handling_48 {
   zend_error_handling_t handling ;
   zend_class_entry *exception ;
   zval *user_handler ;
};
typedef struct __anonstruct_zend_error_handling_48 zend_error_handling;
struct _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_49 {
   znode_op op ;
   zval constant ;
   zend_op_array *op_array ;
};
struct _znode {
   int op_type ;
   union __anonunion_u_49 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 *name ;
   int name_length ;
   ulong h ;
   int offset ;
   char *doc_comment ;
   int doc_comment_len ;
   zend_class_entry *ce ;
};
typedef struct _zend_property_info zend_property_info;
struct _zend_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 *name ;
   int name_len ;
   ulong hash_value ;
};
typedef struct _zend_compiled_variable zend_compiled_variable;
struct _zend_op_array {
   zend_uchar type ;
   char *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
   zend_uint *refcount ;
   zend_op *opcodes ;
   zend_uint last ;
   zend_compiled_variable *vars ;
   int last_var ;
   zend_uint T ;
   zend_brk_cont_element *brk_cont_array ;
   int last_brk_cont ;
   zend_try_catch_element *try_catch_array ;
   int last_try_catch ;
   HashTable *static_variables ;
   zend_uint this_var ;
   char *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char *doc_comment ;
   zend_uint doc_comment_len ;
   zend_uint early_binding ;
   zend_literal *literals ;
   int last_literal ;
   void **run_time_cache ;
   int last_cache_slot ;
   void *reserved[4] ;
};
struct _zend_internal_function {
   zend_uchar type ;
   char *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
   void (*handler)(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
   struct _zend_module_entry *module ;
};
typedef struct _zend_internal_function zend_internal_function;
struct __anonstruct_common_50 {
   zend_uchar type ;
   char *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
};
union _zend_function {
   zend_uchar type ;
   struct __anonstruct_common_50 common ;
   zend_op_array op_array ;
   zend_internal_function internal_function ;
};
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 __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_51 {
   int next ;
};
union _store_bucket {
   struct _store_object obj ;
   struct __anonstruct_free_list_51 free_list ;
};
struct _zend_object_store_bucket {
   zend_bool destructor_called ;
   zend_bool valid ;
   union _store_bucket bucket ;
};
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;
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;
struct _zend_ini_entry;
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 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 ;
};
typedef int (*unary_op_type)(zval * , zval * );
typedef int (*binary_op_type)(zval * , zval * , zval * );
typedef zend_bool (*zend_auto_global_callback)(char *name , uint name_len );
struct _zend_auto_global {
   char *name ;
   uint name_len ;
   zend_bool (*auto_global_callback)(char *name , uint name_len ) ;
   zend_bool jit ;
   zend_bool armed ;
};
typedef struct _zend_auto_global zend_auto_global;
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 ;
};
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_52 {
   zval **ptr_ptr ;
   zval *ptr ;
   zend_bool fcall_returned_reference ;
};
struct __anonstruct_str_offset_53 {
   zval **ptr_ptr ;
   zval *str ;
   zend_uint offset ;
};
struct __anonstruct_fe_54 {
   zval **ptr_ptr ;
   zval *ptr ;
   HashPointer fe_pos ;
};
union _temp_variable {
   zval tmp_var ;
   struct __anonstruct_var_52 var ;
   struct __anonstruct_str_offset_53 str_offset ;
   struct __anonstruct_fe_54 fe ;
   zend_class_entry *class_entry ;
};
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;
enum __anonenum_55 {
    _ISupper = 256,
    _ISlower = 512,
    _ISalpha = 1024,
    _ISdigit = 2048,
    _ISxdigit = 4096,
    _ISspace = 8192,
    _ISprint = 16384,
    _ISgraph = 32768,
    _ISblank = 1,
    _IScntrl = 2,
    _ISpunct = 4,
    _ISalnum = 8
} ;
typedef __intptr_t intptr_t;
typedef __socklen_t socklen_t;
enum __anonenum_56 {
    _PC_LINK_MAX = 0,
    _PC_MAX_CANON = 1,
    _PC_MAX_INPUT = 2,
    _PC_NAME_MAX = 3,
    _PC_PATH_MAX = 4,
    _PC_PIPE_BUF = 5,
    _PC_CHOWN_RESTRICTED = 6,
    _PC_NO_TRUNC = 7,
    _PC_VDISABLE = 8,
    _PC_SYNC_IO = 9,
    _PC_ASYNC_IO = 10,
    _PC_PRIO_IO = 11,
    _PC_SOCK_MAXBUF = 12,
    _PC_FILESIZEBITS = 13,
    _PC_REC_INCR_XFER_SIZE = 14,
    _PC_REC_MAX_XFER_SIZE = 15,
    _PC_REC_MIN_XFER_SIZE = 16,
    _PC_REC_XFER_ALIGN = 17,
    _PC_ALLOC_SIZE_MIN = 18,
    _PC_SYMLINK_MAX = 19,
    _PC_2_SYMLINKS = 20
} ;
enum __anonenum_57 {
    _SC_ARG_MAX = 0,
    _SC_CHILD_MAX = 1,
    _SC_CLK_TCK = 2,
    _SC_NGROUPS_MAX = 3,
    _SC_OPEN_MAX = 4,
    _SC_STREAM_MAX = 5,
    _SC_TZNAME_MAX = 6,
    _SC_JOB_CONTROL = 7,
    _SC_SAVED_IDS = 8,
    _SC_REALTIME_SIGNALS = 9,
    _SC_PRIORITY_SCHEDULING = 10,
    _SC_TIMERS = 11,
    _SC_ASYNCHRONOUS_IO = 12,
    _SC_PRIORITIZED_IO = 13,
    _SC_SYNCHRONIZED_IO = 14,
    _SC_FSYNC = 15,
    _SC_MAPPED_FILES = 16,
    _SC_MEMLOCK = 17,
    _SC_MEMLOCK_RANGE = 18,
    _SC_MEMORY_PROTECTION = 19,
    _SC_MESSAGE_PASSING = 20,
    _SC_SEMAPHORES = 21,
    _SC_SHARED_MEMORY_OBJECTS = 22,
    _SC_AIO_LISTIO_MAX = 23,
    _SC_AIO_MAX = 24,
    _SC_AIO_PRIO_DELTA_MAX = 25,
    _SC_DELAYTIMER_MAX = 26,
    _SC_MQ_OPEN_MAX = 27,
    _SC_MQ_PRIO_MAX = 28,
    _SC_VERSION = 29,
    _SC_PAGESIZE = 30,
    _SC_RTSIG_MAX = 31,
    _SC_SEM_NSEMS_MAX = 32,
    _SC_SEM_VALUE_MAX = 33,
    _SC_SIGQUEUE_MAX = 34,
    _SC_TIMER_MAX = 35,
    _SC_BC_BASE_MAX = 36,
    _SC_BC_DIM_MAX = 37,
    _SC_BC_SCALE_MAX = 38,
    _SC_BC_STRING_MAX = 39,
    _SC_COLL_WEIGHTS_MAX = 40,
    _SC_EQUIV_CLASS_MAX = 41,
    _SC_EXPR_NEST_MAX = 42,
    _SC_LINE_MAX = 43,
    _SC_RE_DUP_MAX = 44,
    _SC_CHARCLASS_NAME_MAX = 45,
    _SC_2_VERSION = 46,
    _SC_2_C_BIND = 47,
    _SC_2_C_DEV = 48,
    _SC_2_FORT_DEV = 49,
    _SC_2_FORT_RUN = 50,
    _SC_2_SW_DEV = 51,
    _SC_2_LOCALEDEF = 52,
    _SC_PII = 53,
    _SC_PII_XTI = 54,
    _SC_PII_SOCKET = 55,
    _SC_PII_INTERNET = 56,
    _SC_PII_OSI = 57,
    _SC_POLL = 58,
    _SC_SELECT = 59,
    _SC_UIO_MAXIOV = 60,
    _SC_IOV_MAX = 60,
    _SC_PII_INTERNET_STREAM = 61,
    _SC_PII_INTERNET_DGRAM = 62,
    _SC_PII_OSI_COTS = 63,
    _SC_PII_OSI_CLTS = 64,
    _SC_PII_OSI_M = 65,
    _SC_T_IOV_MAX = 66,
    _SC_THREADS = 67,
    _SC_THREAD_SAFE_FUNCTIONS = 68,
    _SC_GETGR_R_SIZE_MAX = 69,
    _SC_GETPW_R_SIZE_MAX = 70,
    _SC_LOGIN_NAME_MAX = 71,
    _SC_TTY_NAME_MAX = 72,
    _SC_THREAD_DESTRUCTOR_ITERATIONS = 73,
    _SC_THREAD_KEYS_MAX = 74,
    _SC_THREAD_STACK_MIN = 75,
    _SC_THREAD_THREADS_MAX = 76,
    _SC_THREAD_ATTR_STACKADDR = 77,
    _SC_THREAD_ATTR_STACKSIZE = 78,
    _SC_THREAD_PRIORITY_SCHEDULING = 79,
    _SC_THREAD_PRIO_INHERIT = 80,
    _SC_THREAD_PRIO_PROTECT = 81,
    _SC_THREAD_PROCESS_SHARED = 82,
    _SC_NPROCESSORS_CONF = 83,
    _SC_NPROCESSORS_ONLN = 84,
    _SC_PHYS_PAGES = 85,
    _SC_AVPHYS_PAGES = 86,
    _SC_ATEXIT_MAX = 87,
    _SC_PASS_MAX = 88,
    _SC_XOPEN_VERSION = 89,
    _SC_XOPEN_XCU_VERSION = 90,
    _SC_XOPEN_UNIX = 91,
    _SC_XOPEN_CRYPT = 92,
    _SC_XOPEN_ENH_I18N = 93,
    _SC_XOPEN_SHM = 94,
    _SC_2_CHAR_TERM = 95,
    _SC_2_C_VERSION = 96,
    _SC_2_UPE = 97,
    _SC_XOPEN_XPG2 = 98,
    _SC_XOPEN_XPG3 = 99,
    _SC_XOPEN_XPG4 = 100,
    _SC_CHAR_BIT = 101,
    _SC_CHAR_MAX = 102,
    _SC_CHAR_MIN = 103,
    _SC_INT_MAX = 104,
    _SC_INT_MIN = 105,
    _SC_LONG_BIT = 106,
    _SC_WORD_BIT = 107,
    _SC_MB_LEN_MAX = 108,
    _SC_NZERO = 109,
    _SC_SSIZE_MAX = 110,
    _SC_SCHAR_MAX = 111,
    _SC_SCHAR_MIN = 112,
    _SC_SHRT_MAX = 113,
    _SC_SHRT_MIN = 114,
    _SC_UCHAR_MAX = 115,
    _SC_UINT_MAX = 116,
    _SC_ULONG_MAX = 117,
    _SC_USHRT_MAX = 118,
    _SC_NL_ARGMAX = 119,
    _SC_NL_LANGMAX = 120,
    _SC_NL_MSGMAX = 121,
    _SC_NL_NMAX = 122,
    _SC_NL_SETMAX = 123,
    _SC_NL_TEXTMAX = 124,
    _SC_XBS5_ILP32_OFF32 = 125,
    _SC_XBS5_ILP32_OFFBIG = 126,
    _SC_XBS5_LP64_OFF64 = 127,
    _SC_XBS5_LPBIG_OFFBIG = 128,
    _SC_XOPEN_LEGACY = 129,
    _SC_XOPEN_REALTIME = 130,
    _SC_XOPEN_REALTIME_THREADS = 131,
    _SC_ADVISORY_INFO = 132,
    _SC_BARRIERS = 133,
    _SC_BASE = 134,
    _SC_C_LANG_SUPPORT = 135,
    _SC_C_LANG_SUPPORT_R = 136,
    _SC_CLOCK_SELECTION = 137,
    _SC_CPUTIME = 138,
    _SC_THREAD_CPUTIME = 139,
    _SC_DEVICE_IO = 140,
    _SC_DEVICE_SPECIFIC = 141,
    _SC_DEVICE_SPECIFIC_R = 142,
    _SC_FD_MGMT = 143,
    _SC_FIFO = 144,
    _SC_PIPE = 145,
    _SC_FILE_ATTRIBUTES = 146,
    _SC_FILE_LOCKING = 147,
    _SC_FILE_SYSTEM = 148,
    _SC_MONOTONIC_CLOCK = 149,
    _SC_MULTI_PROCESS = 150,
    _SC_SINGLE_PROCESS = 151,
    _SC_NETWORKING = 152,
    _SC_READER_WRITER_LOCKS = 153,
    _SC_SPIN_LOCKS = 154,
    _SC_REGEXP = 155,
    _SC_REGEX_VERSION = 156,
    _SC_SHELL = 157,
    _SC_SIGNALS = 158,
    _SC_SPAWN = 159,
    _SC_SPORADIC_SERVER = 160,
    _SC_THREAD_SPORADIC_SERVER = 161,
    _SC_SYSTEM_DATABASE = 162,
    _SC_SYSTEM_DATABASE_R = 163,
    _SC_TIMEOUTS = 164,
    _SC_TYPED_MEMORY_OBJECTS = 165,
    _SC_USER_GROUPS = 166,
    _SC_USER_GROUPS_R = 167,
    _SC_2_PBS = 168,
    _SC_2_PBS_ACCOUNTING = 169,
    _SC_2_PBS_LOCATE = 170,
    _SC_2_PBS_MESSAGE = 171,
    _SC_2_PBS_TRACK = 172,
    _SC_SYMLOOP_MAX = 173,
    _SC_STREAMS = 174,
    _SC_2_PBS_CHECKPOINT = 175,
    _SC_V6_ILP32_OFF32 = 176,
    _SC_V6_ILP32_OFFBIG = 177,
    _SC_V6_LP64_OFF64 = 178,
    _SC_V6_LPBIG_OFFBIG = 179,
    _SC_HOST_NAME_MAX = 180,
    _SC_TRACE = 181,
    _SC_TRACE_EVENT_FILTER = 182,
    _SC_TRACE_INHERIT = 183,
    _SC_TRACE_LOG = 184,
    _SC_LEVEL1_ICACHE_SIZE = 185,
    _SC_LEVEL1_ICACHE_ASSOC = 186,
    _SC_LEVEL1_ICACHE_LINESIZE = 187,
    _SC_LEVEL1_DCACHE_SIZE = 188,
    _SC_LEVEL1_DCACHE_ASSOC = 189,
    _SC_LEVEL1_DCACHE_LINESIZE = 190,
    _SC_LEVEL2_CACHE_SIZE = 191,
    _SC_LEVEL2_CACHE_ASSOC = 192,
    _SC_LEVEL2_CACHE_LINESIZE = 193,
    _SC_LEVEL3_CACHE_SIZE = 194,
    _SC_LEVEL3_CACHE_ASSOC = 195,
    _SC_LEVEL3_CACHE_LINESIZE = 196,
    _SC_LEVEL4_CACHE_SIZE = 197,
    _SC_LEVEL4_CACHE_ASSOC = 198,
    _SC_LEVEL4_CACHE_LINESIZE = 199,
    _SC_IPV6 = 235,
    _SC_RAW_SOCKETS = 236,
    _SC_V7_ILP32_OFF32 = 237,
    _SC_V7_ILP32_OFFBIG = 238,
    _SC_V7_LP64_OFF64 = 239,
    _SC_V7_LPBIG_OFFBIG = 240,
    _SC_SS_REPL_MAX = 241,
    _SC_TRACE_EVENT_NAME_MAX = 242,
    _SC_TRACE_NAME_MAX = 243,
    _SC_TRACE_SYS_MAX = 244,
    _SC_TRACE_USER_EVENT_MAX = 245,
    _SC_XOPEN_STREAMS = 246,
    _SC_THREAD_ROBUST_PRIO_INHERIT = 247,
    _SC_THREAD_ROBUST_PRIO_PROTECT = 248
} ;
enum __anonenum_58 {
    _CS_PATH = 0,
    _CS_V6_WIDTH_RESTRICTED_ENVS = 1,
    _CS_GNU_LIBC_VERSION = 2,
    _CS_GNU_LIBPTHREAD_VERSION = 3,
    _CS_V5_WIDTH_RESTRICTED_ENVS = 4,
    _CS_V7_WIDTH_RESTRICTED_ENVS = 5,
    _CS_LFS_CFLAGS = 1000,
    _CS_LFS_LDFLAGS = 1001,
    _CS_LFS_LIBS = 1002,
    _CS_LFS_LINTFLAGS = 1003,
    _CS_LFS64_CFLAGS = 1004,
    _CS_LFS64_LDFLAGS = 1005,
    _CS_LFS64_LIBS = 1006,
    _CS_LFS64_LINTFLAGS = 1007,
    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
    _CS_XBS5_ILP32_OFF32_LDFLAGS = 1101,
    _CS_XBS5_ILP32_OFF32_LIBS = 1102,
    _CS_XBS5_ILP32_OFF32_LINTFLAGS = 1103,
    _CS_XBS5_ILP32_OFFBIG_CFLAGS = 1104,
    _CS_XBS5_ILP32_OFFBIG_LDFLAGS = 1105,
    _CS_XBS5_ILP32_OFFBIG_LIBS = 1106,
    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 1107,
    _CS_XBS5_LP64_OFF64_CFLAGS = 1108,
    _CS_XBS5_LP64_OFF64_LDFLAGS = 1109,
    _CS_XBS5_LP64_OFF64_LIBS = 1110,
    _CS_XBS5_LP64_OFF64_LINTFLAGS = 1111,
    _CS_XBS5_LPBIG_OFFBIG_CFLAGS = 1112,
    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS = 1113,
    _CS_XBS5_LPBIG_OFFBIG_LIBS = 1114,
    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 1115,
    _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116,
    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117,
    _CS_POSIX_V6_ILP32_OFF32_LIBS = 1118,
    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS = 1119,
    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120,
    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121,
    _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122,
    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123,
    _CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124,
    _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125,
    _CS_POSIX_V6_LP64_OFF64_LIBS = 1126,
    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS = 1127,
    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128,
    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129,
    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130,
    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131,
    _CS_POSIX_V7_ILP32_OFF32_CFLAGS = 1132,
    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS = 1133,
    _CS_POSIX_V7_ILP32_OFF32_LIBS = 1134,
    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS = 1135,
    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS = 1136,
    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS = 1137,
    _CS_POSIX_V7_ILP32_OFFBIG_LIBS = 1138,
    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139,
    _CS_POSIX_V7_LP64_OFF64_CFLAGS = 1140,
    _CS_POSIX_V7_LP64_OFF64_LDFLAGS = 1141,
    _CS_POSIX_V7_LP64_OFF64_LIBS = 1142,
    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS = 1143,
    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS = 1144,
    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS = 1145,
    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS = 1146,
    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147,
    _CS_V6_ENV = 1148,
    _CS_V7_ENV = 1149
} ;
struct passwd {
   char *pw_name ;
   char *pw_passwd ;
   __uid_t pw_uid ;
   __gid_t pw_gid ;
   char *pw_gecos ;
   char *pw_dir ;
   char *pw_shell ;
};
typedef int bool_int;
enum __anonenum_boolean_e_59 {
    NO = 0,
    YES = 1
} ;
typedef enum __anonenum_boolean_e_59 boolean_e;
enum __anonenum_length_modifier_e_60 {
    LM_STD = 0,
    LM_INTMAX_T = 1,
    LM_PTRDIFF_T = 2,
    LM_LONG_LONG = 3,
    LM_SIZE_T = 4,
    LM_LONG = 5,
    LM_LONG_DOUBLE = 6
} ;
typedef enum __anonenum_length_modifier_e_60 length_modifier_e;
typedef long long wide_int;
typedef unsigned long long u_wide_int;
enum _php_output_handler_status_t {
    PHP_OUTPUT_HANDLER_FAILURE = 0,
    PHP_OUTPUT_HANDLER_SUCCESS = 1,
    PHP_OUTPUT_HANDLER_NO_DATA = 2
} ;
typedef enum _php_output_handler_status_t php_output_handler_status_t;
enum _php_output_handler_hook_t {
    PHP_OUTPUT_HANDLER_HOOK_GET_OPAQ = 0,
    PHP_OUTPUT_HANDLER_HOOK_GET_FLAGS = 1,
    PHP_OUTPUT_HANDLER_HOOK_GET_LEVEL = 2,
    PHP_OUTPUT_HANDLER_HOOK_IMMUTABLE = 3,
    PHP_OUTPUT_HANDLER_HOOK_DISABLE = 4,
    PHP_OUTPUT_HANDLER_HOOK_LAST = 5
} ;
typedef enum _php_output_handler_hook_t php_output_handler_hook_t;
struct _php_output_buffer {
   char *data ;
   size_t size ;
   size_t used ;
   uint free : 1 ;
   uint _res : 31 ;
};
typedef struct _php_output_buffer php_output_buffer;
struct _php_output_context {
   int op ;
   php_output_buffer in ;
   php_output_buffer out ;
};
typedef struct _php_output_context php_output_context;
typedef void (*php_output_handler_func_t)(char *output , uint output_len ,
                                          char **handled_output ,
                                          uint *handled_output_len , int mode );
typedef int (*php_output_handler_context_func_t)(void **handler_context ,
                                                 php_output_context *output_context );
typedef void (*php_output_handler_context_dtor_t)(void *opaq );
typedef int (*php_output_handler_conflict_check_t)(char const   *handler_name ,
                                                   size_t handler_name_len );
struct _php_output_handler;
typedef struct _php_output_handler *(*php_output_handler_alias_ctor_t)(char const   *handler_name ,
                                                                       size_t handler_name_len ,
                                                                       size_t chunk_size ,
                                                                       int flags );
struct _php_output_handler_user_func_t {
   zend_fcall_info fci ;
   zend_fcall_info_cache fcc ;
   zval *zoh ;
};
typedef struct _php_output_handler_user_func_t php_output_handler_user_func_t;
union __anonunion_func_61 {
   php_output_handler_user_func_t *user ;
   int (*internal)(void **handler_context , php_output_context *output_context ) ;
};
struct _php_output_handler {
   char *name ;
   size_t name_len ;
   int flags ;
   int level ;
   size_t size ;
   php_output_buffer buffer ;
   void *opaq ;
   void (*dtor)(void *opaq ) ;
   union __anonunion_func_61 func ;
};
typedef struct _php_output_handler php_output_handler;
struct _zend_output_globals {
   int flags ;
   zend_stack handlers ;
   php_output_handler *active ;
   php_output_handler *running ;
   char *output_start_filename ;
   int output_start_lineno ;
};
typedef struct _zend_output_globals zend_output_globals;
struct timezone {
   int tz_minuteswest ;
   int tz_dsttime ;
};
typedef struct timezone * __restrict  __timezone_ptr_t;
enum __itimer_which {
    ITIMER_REAL = 0,
    ITIMER_VIRTUAL = 1,
    ITIMER_PROF = 2
} ;
struct itimerval {
   struct timeval it_interval ;
   struct timeval it_value ;
};
typedef enum __itimer_which __itimer_which_t;
struct stat {
   __dev_t st_dev ;
   unsigned short __pad1 ;
   __ino_t st_ino ;
   __mode_t st_mode ;
   __nlink_t st_nlink ;
   __uid_t st_uid ;
   __gid_t st_gid ;
   __dev_t st_rdev ;
   unsigned short __pad2 ;
   __off_t st_size ;
   __blksize_t st_blksize ;
   __blkcnt_t st_blocks ;
   struct timespec st_atim ;
   struct timespec st_mtim ;
   struct timespec st_ctim ;
   unsigned long __unused4 ;
   unsigned long __unused5 ;
};
struct stat64 {
   __dev_t st_dev ;
   unsigned int __pad1 ;
   __ino_t __st_ino ;
   __mode_t st_mode ;
   __nlink_t st_nlink ;
   __uid_t st_uid ;
   __gid_t st_gid ;
   __dev_t st_rdev ;
   unsigned int __pad2 ;
   __off64_t st_size ;
   __blksize_t st_blksize ;
   __blkcnt64_t st_blocks ;
   struct timespec st_atim ;
   struct timespec st_mtim ;
   struct timespec st_ctim ;
   __ino64_t st_ino ;
};
struct _php_stream;
typedef struct _php_stream php_stream;
struct _php_stream_wrapper;
typedef struct _php_stream_wrapper php_stream_wrapper;
struct _php_stream_context;
typedef struct _php_stream_context php_stream_context;
struct _php_stream_filter;
typedef struct _php_stream_filter php_stream_filter;
typedef void (*php_stream_notification_func)(php_stream_context *context ,
                                             int notifycode , int severity ,
                                             char *xmsg , int xcode ,
                                             size_t bytes_sofar ,
                                             size_t bytes_max , void *ptr );
struct _php_stream_notifier;
typedef struct _php_stream_notifier php_stream_notifier;
struct _php_stream_notifier {
   void (*func)(php_stream_context *context , int notifycode , int severity ,
                char *xmsg , int xcode , size_t bytes_sofar , size_t bytes_max ,
                void *ptr ) ;
   void (*dtor)(php_stream_notifier *notifier ) ;
   void *ptr ;
   int mask ;
   size_t progress ;
   size_t progress_max ;
};
struct _php_stream_context {
   php_stream_notifier *notifier ;
   zval *options ;
   zval *links ;
   int rsrc_id ;
};
struct _php_stream_bucket;
typedef struct _php_stream_bucket php_stream_bucket;
struct _php_stream_bucket_brigade;
typedef struct _php_stream_bucket_brigade php_stream_bucket_brigade;
struct _php_stream_bucket {
   php_stream_bucket *next ;
   php_stream_bucket *prev ;
   php_stream_bucket_brigade *brigade ;
   char *buf ;
   size_t buflen ;
   int own_buf ;
   int is_persistent ;
   int refcount ;
};
struct _php_stream_bucket_brigade {
   php_stream_bucket *head ;
   php_stream_bucket *tail ;
};
enum __anonenum_php_stream_filter_status_t_62 {
    PSFS_ERR_FATAL = 0,
    PSFS_FEED_ME = 1,
    PSFS_PASS_ON = 2
} ;
typedef enum __anonenum_php_stream_filter_status_t_62 php_stream_filter_status_t;
struct _php_stream_filter_ops {
   php_stream_filter_status_t (*filter)(php_stream *stream ,
                                        php_stream_filter *thisfilter ,
                                        php_stream_bucket_brigade *buckets_in ,
                                        php_stream_bucket_brigade *buckets_out ,
                                        size_t *bytes_consumed , int flags ) ;
   void (*dtor)(php_stream_filter *thisfilter ) ;
   char const   *label ;
};
typedef struct _php_stream_filter_ops php_stream_filter_ops;
struct _php_stream_filter_chain {
   php_stream_filter *head ;
   php_stream_filter *tail ;
   php_stream *stream ;
};
typedef struct _php_stream_filter_chain php_stream_filter_chain;
struct _php_stream_filter {
   php_stream_filter_ops *fops ;
   void *abstract ;
   php_stream_filter *next ;
   php_stream_filter *prev ;
   int is_persistent ;
   php_stream_filter_chain *chain ;
   php_stream_bucket_brigade buffer ;
   int rsrc_id ;
};
struct _php_stream_filter_factory {
   php_stream_filter *(*create_filter)(char const   *filtername ,
                                       zval *filterparams , int persistent ) ;
};
typedef struct _php_stream_filter_factory php_stream_filter_factory;
struct _php_stream_statbuf {
   struct stat sb ;
};
typedef struct _php_stream_statbuf php_stream_statbuf;
struct _php_stream_dirent {
   char d_name[4096] ;
};
typedef struct _php_stream_dirent php_stream_dirent;
struct _php_stream_ops {
   size_t (*write)(php_stream *stream , char const   *buf , size_t count ) ;
   size_t (*read)(php_stream *stream , char *buf , size_t count ) ;
   int (*close)(php_stream *stream , int close_handle ) ;
   int (*flush)(php_stream *stream ) ;
   char const   *label ;
   int (*seek)(php_stream *stream , off_t offset , int whence ,
               off_t *newoffset ) ;
   int (*cast)(php_stream *stream , int castas , void **ret ) ;
   int (*stat)(php_stream *stream , php_stream_statbuf *ssb ) ;
   int (*set_option)(php_stream *stream , int option , int value ,
                     void *ptrparam ) ;
};
typedef struct _php_stream_ops php_stream_ops;
struct _php_stream_wrapper_ops {
   php_stream *(*stream_opener)(php_stream_wrapper *wrapper , char *filename ,
                                char *mode , int options , char **opened_path ,
                                php_stream_context *context ) ;
   int (*stream_closer)(php_stream_wrapper *wrapper , php_stream *stream ) ;
   int (*stream_stat)(php_stream_wrapper *wrapper , php_stream *stream ,
                      php_stream_statbuf *ssb ) ;
   int (*url_stat)(php_stream_wrapper *wrapper , char *url , int flags ,
                   php_stream_statbuf *ssb , php_stream_context *context ) ;
   php_stream *(*dir_opener)(php_stream_wrapper *wrapper , char *filename ,
                             char *mode , int options , char **opened_path ,
                             php_stream_context *context ) ;
   char const   *label ;
   int (*unlink)(php_stream_wrapper *wrapper , char *url , int options ,
                 php_stream_context *context ) ;
   int (*rename)(php_stream_wrapper *wrapper , char *url_from , char *url_to ,
                 int options , php_stream_context *context ) ;
   int (*stream_mkdir)(php_stream_wrapper *wrapper , char *url , int mode ,
                       int options , php_stream_context *context ) ;
   int (*stream_rmdir)(php_stream_wrapper *wrapper , char *url , int options ,
                       php_stream_context *context ) ;
};
typedef struct _php_stream_wrapper_ops php_stream_wrapper_ops;
struct _php_stream_wrapper {
   php_stream_wrapper_ops *wops ;
   void *abstract ;
   int is_url ;
   int err_count ;
   char **err_stack ;
};
struct _php_stream {
   php_stream_ops *ops ;
   void *abstract ;
   php_stream_filter_chain readfilters ;
   php_stream_filter_chain writefilters ;
   php_stream_wrapper *wrapper ;
   void *wrapperthis ;
   zval *wrapperdata ;
   int fgetss_state ;
   int is_persistent ;
   char mode[16] ;
   int rsrc_id ;
   int in_free ;
   int fclose_stdiocast ;
   FILE *stdiocast ;
   char *orig_path ;
   php_stream_context *context ;
   int flags ;
   off_t position ;
   unsigned char *readbuf ;
   size_t readbuflen ;
   off_t readpos ;
   off_t writepos ;
   size_t chunk_size ;
   int eof ;
   struct _php_stream *enclosing_stream ;
};
struct iovec {
   void *iov_base ;
   size_t iov_len ;
};
enum __socket_type {
    SOCK_STREAM = 1,
    SOCK_DGRAM = 2,
    SOCK_RAW = 3,
    SOCK_RDM = 4,
    SOCK_SEQPACKET = 5,
    SOCK_DCCP = 6,
    SOCK_PACKET = 10,
    SOCK_CLOEXEC = 524288,
    SOCK_NONBLOCK = 2048
} ;
typedef unsigned short sa_family_t;
struct sockaddr {
   sa_family_t sa_family ;
   char sa_data[14] ;
};
struct sockaddr_storage {
   sa_family_t ss_family ;
   unsigned long __ss_align ;
   char __ss_padding[128U - 2U * sizeof(unsigned long )] ;
};
enum __anonenum_63 {
    MSG_OOB = 1,
    MSG_PEEK = 2,
    MSG_DONTROUTE = 4,
    MSG_TRYHARD = 4,
    MSG_CTRUNC = 8,
    MSG_PROXY = 16,
    MSG_TRUNC = 32,
    MSG_DONTWAIT = 64,
    MSG_EOR = 128,
    MSG_WAITALL = 256,
    MSG_FIN = 512,
    MSG_SYN = 1024,
    MSG_CONFIRM = 2048,
    MSG_RST = 4096,
    MSG_ERRQUEUE = 8192,
    MSG_NOSIGNAL = 16384,
    MSG_MORE = 32768,
    MSG_WAITFORONE = 65536,
    MSG_CMSG_CLOEXEC = 1073741824
} ;
struct msghdr {
   void *msg_name ;
   socklen_t msg_namelen ;
   struct iovec *msg_iov ;
   size_t msg_iovlen ;
   void *msg_control ;
   size_t msg_controllen ;
   int msg_flags ;
};
struct mmsghdr {
   struct msghdr msg_hdr ;
   unsigned int msg_len ;
};
struct cmsghdr {
   size_t cmsg_len ;
   int cmsg_level ;
   int cmsg_type ;
   unsigned char __cmsg_data[] ;
};
enum __anonenum_64 {
    SCM_RIGHTS = 1,
    SCM_CREDENTIALS = 2
} ;
struct ucred {
   pid_t pid ;
   uid_t uid ;
   gid_t gid ;
};
struct linger {
   int l_onoff ;
   int l_linger ;
};
struct osockaddr {
   unsigned short sa_family ;
   unsigned char sa_data[14] ;
};
enum __anonenum_65 {
    SHUT_RD = 0,
    SHUT_WR = 1,
    SHUT_RDWR = 2
} ;
struct sockaddr_at;
struct sockaddr_ax25;
struct sockaddr_dl;
struct sockaddr_eon;
struct sockaddr_in;
struct sockaddr_in6;
struct sockaddr_inarp;
struct sockaddr_ipx;
struct sockaddr_iso;
struct sockaddr_ns;
struct sockaddr_un;
struct sockaddr_x25;
union __anonunion___SOCKADDR_ARG_66 {
   struct sockaddr * __restrict  __sockaddr__ ;
   struct sockaddr_at * __restrict  __sockaddr_at__ ;
   struct sockaddr_ax25 * __restrict  __sockaddr_ax25__ ;
   struct sockaddr_dl * __restrict  __sockaddr_dl__ ;
   struct sockaddr_eon * __restrict  __sockaddr_eon__ ;
   struct sockaddr_in * __restrict  __sockaddr_in__ ;
   struct sockaddr_in6 * __restrict  __sockaddr_in6__ ;
   struct sockaddr_inarp * __restrict  __sockaddr_inarp__ ;
   struct sockaddr_ipx * __restrict  __sockaddr_ipx__ ;
   struct sockaddr_iso * __restrict  __sockaddr_iso__ ;
   struct sockaddr_ns * __restrict  __sockaddr_ns__ ;
   struct sockaddr_un * __restrict  __sockaddr_un__ ;
   struct sockaddr_x25 * __restrict  __sockaddr_x25__ ;
};
typedef union __anonunion___SOCKADDR_ARG_66  __attribute__((__transparent_union__)) __SOCKADDR_ARG;
union __anonunion___CONST_SOCKADDR_ARG_67 {
   struct sockaddr  const  * __restrict  __sockaddr__ ;
   struct sockaddr_at  const  * __restrict  __sockaddr_at__ ;
   struct sockaddr_ax25  const  * __restrict  __sockaddr_ax25__ ;
   struct sockaddr_dl  const  * __restrict  __sockaddr_dl__ ;
   struct sockaddr_eon  const  * __restrict  __sockaddr_eon__ ;
   struct sockaddr_in  const  * __restrict  __sockaddr_in__ ;
   struct sockaddr_in6  const  * __restrict  __sockaddr_in6__ ;
   struct sockaddr_inarp  const  * __restrict  __sockaddr_inarp__ ;
   struct sockaddr_ipx  const  * __restrict  __sockaddr_ipx__ ;
   struct sockaddr_iso  const  * __restrict  __sockaddr_iso__ ;
   struct sockaddr_ns  const  * __restrict  __sockaddr_ns__ ;
   struct sockaddr_un  const  * __restrict  __sockaddr_un__ ;
   struct sockaddr_x25  const  * __restrict  __sockaddr_x25__ ;
};
typedef union __anonunion___CONST_SOCKADDR_ARG_67  __attribute__((__transparent_union__)) __CONST_SOCKADDR_ARG;
typedef php_stream *php_stream_transport_factory_func(char const   *proto ,
                                                      long protolen ,
                                                      char *resourcename ,
                                                      long resourcenamelen ,
                                                      char const   *persistent_id ,
                                                      int options , int flags ,
                                                      struct timeval *timeout ,
                                                      php_stream_context *context );
typedef php_stream_transport_factory_func *php_stream_transport_factory;
enum php_stream_xport_send_recv_flags {
    STREAM_OOB = 1,
    STREAM_PEEK = 2
} ;
enum __anonenum_stream_shutdown_t_68 {
    STREAM_SHUT_RD = 0,
    STREAM_SHUT_WR = 1,
    STREAM_SHUT_RDWR = 2
} ;
typedef enum __anonenum_stream_shutdown_t_68 stream_shutdown_t;
enum __anonenum_op_69 {
    STREAM_XPORT_OP_BIND = 0,
    STREAM_XPORT_OP_CONNECT = 1,
    STREAM_XPORT_OP_LISTEN = 2,
    STREAM_XPORT_OP_ACCEPT = 3,
    STREAM_XPORT_OP_CONNECT_ASYNC = 4,
    STREAM_XPORT_OP_GET_NAME = 5,
    STREAM_XPORT_OP_GET_PEER_NAME = 6,
    STREAM_XPORT_OP_RECV = 7,
    STREAM_XPORT_OP_SEND = 8,
    STREAM_XPORT_OP_SHUTDOWN = 9
} ;
struct __anonstruct_inputs_70 {
   char *name ;
   long namelen ;
   int backlog ;
   struct timeval *timeout ;
   struct sockaddr *addr ;
   socklen_t addrlen ;
   char *buf ;
   size_t buflen ;
   long flags ;
};
struct __anonstruct_outputs_71 {
   php_stream *client ;
   int returncode ;
   struct sockaddr *addr ;
   socklen_t addrlen ;
   char *textaddr ;
   long textaddrlen ;
   char *error_text ;
   int error_code ;
};
struct _php_stream_xport_param {
   enum __anonenum_op_69 op ;
   unsigned int want_addr : 1 ;
   unsigned int want_textaddr : 1 ;
   unsigned int want_errortext : 1 ;
   unsigned int how : 2 ;
   struct __anonstruct_inputs_70 inputs ;
   struct __anonstruct_outputs_71 outputs ;
};
typedef struct _php_stream_xport_param php_stream_xport_param;
enum __anonenum_php_stream_xport_crypt_method_t_72 {
    STREAM_CRYPTO_METHOD_SSLv2_CLIENT = 0,
    STREAM_CRYPTO_METHOD_SSLv3_CLIENT = 1,
    STREAM_CRYPTO_METHOD_SSLv23_CLIENT = 2,
    STREAM_CRYPTO_METHOD_TLS_CLIENT = 3,
    STREAM_CRYPTO_METHOD_SSLv2_SERVER = 4,
    STREAM_CRYPTO_METHOD_SSLv3_SERVER = 5,
    STREAM_CRYPTO_METHOD_SSLv23_SERVER = 6,
    STREAM_CRYPTO_METHOD_TLS_SERVER = 7
} ;
typedef enum __anonenum_php_stream_xport_crypt_method_t_72 php_stream_xport_crypt_method_t;
enum __anonenum_op_73 {
    STREAM_XPORT_CRYPTO_OP_SETUP = 0,
    STREAM_XPORT_CRYPTO_OP_ENABLE = 1
} ;
struct __anonstruct_inputs_74 {
   int activate ;
   php_stream_xport_crypt_method_t method ;
   php_stream *session ;
};
struct __anonstruct_outputs_75 {
   int returncode ;
};
struct _php_stream_xport_crypto_param {
   enum __anonenum_op_73 op ;
   struct __anonstruct_inputs_74 inputs ;
   struct __anonstruct_outputs_75 outputs ;
};
typedef struct _php_stream_xport_crypto_param php_stream_xport_crypto_param;
enum __anonenum_php_stream_mmap_operation_t_76 {
    PHP_STREAM_MMAP_SUPPORTED = 0,
    PHP_STREAM_MMAP_MAP_RANGE = 1,
    PHP_STREAM_MMAP_UNMAP = 2
} ;
typedef enum __anonenum_php_stream_mmap_operation_t_76 php_stream_mmap_operation_t;
enum __anonenum_php_stream_mmap_access_t_77 {
    PHP_STREAM_MAP_MODE_READONLY = 0,
    PHP_STREAM_MAP_MODE_READWRITE = 1,
    PHP_STREAM_MAP_MODE_SHARED_READONLY = 2,
    PHP_STREAM_MAP_MODE_SHARED_READWRITE = 3
} ;
typedef enum __anonenum_php_stream_mmap_access_t_77 php_stream_mmap_access_t;
struct __anonstruct_php_stream_mmap_range_78 {
   size_t offset ;
   size_t length ;
   php_stream_mmap_access_t mode ;
   char *mapped ;
};
typedef struct __anonstruct_php_stream_mmap_range_78 php_stream_mmap_range;
struct _php_core_globals;
typedef struct _php_core_globals php_core_globals;
struct _php_tick_function_entry;
struct _arg_separators {
   char *output ;
   char *input ;
};
typedef struct _arg_separators arg_separators;
struct _php_core_globals {
   zend_bool magic_quotes_gpc ;
   zend_bool magic_quotes_runtime ;
   zend_bool magic_quotes_sybase ;
   zend_bool implicit_flush ;
   long output_buffering ;
   zend_bool sql_safe_mode ;
   zend_bool enable_dl ;
   char *output_handler ;
   char *unserialize_callback_func ;
   long serialize_precision ;
   long memory_limit ;
   long max_input_time ;
   zend_bool track_errors ;
   zend_bool display_errors ;
   zend_bool display_startup_errors ;
   zend_bool log_errors ;
   long log_errors_max_len ;
   zend_bool ignore_repeated_errors ;
   zend_bool ignore_repeated_source ;
   zend_bool report_memleaks ;
   char *error_log ;
   char *doc_root ;
   char *user_dir ;
   char *include_path ;
   char *open_basedir ;
   char *extension_dir ;
   char *upload_tmp_dir ;
   long upload_max_filesize ;
   char *error_append_string ;
   char *error_prepend_string ;
   char *auto_prepend_file ;
   char *auto_append_file ;
   arg_separators arg_separator ;
   char *variables_order ;
   HashTable rfc1867_protected_variables ;
   short connection_status ;
   short ignore_user_abort ;
   unsigned char header_is_being_sent ;
   zend_llist tick_functions ;
   zval *http_globals[6] ;
   zend_bool expose_php ;
   zend_bool register_argc_argv ;
   zend_bool auto_globals_jit ;
   char *docref_root ;
   char *docref_ext ;
   zend_bool html_errors ;
   zend_bool xmlrpc_errors ;
   long xmlrpc_error_number ;
   zend_bool activated_auto_globals[8] ;
   zend_bool modules_activated ;
   zend_bool file_uploads ;
   zend_bool during_request_startup ;
   zend_bool allow_url_fopen ;
   zend_bool enable_post_data_reading ;
   zend_bool always_populate_raw_post_data ;
   zend_bool report_zend_debug ;
   int last_error_type ;
   char *last_error_message ;
   char *last_error_file ;
   int last_error_lineno ;
   char *disable_functions ;
   char *disable_classes ;
   zend_bool allow_url_include ;
   zend_bool exit_on_timeout ;
   long max_input_nesting_level ;
   zend_bool in_user_include ;
   char *user_ini_filename ;
   long user_ini_cache_ttl ;
   char *request_order ;
   zend_bool mail_x_header ;
   char *mail_log ;
   zend_bool in_error_log ;
};
struct _zend_ini_entry {
   int module_number ;
   int modifiable ;
   char *name ;
   uint name_length ;
   int (*on_modify)(zend_ini_entry *entry , char *new_value ,
                    uint new_value_length , void *mh_arg1 , void *mh_arg2 ,
                    void *mh_arg3 , int stage ) ;
   void *mh_arg1 ;
   void *mh_arg2 ;
   void *mh_arg3 ;
   char *value ;
   uint value_length ;
   char *orig_value ;
   uint orig_value_length ;
   int orig_modifiable ;
   int modified ;
   void (*displayer)(zend_ini_entry *ini_entry , int type ) ;
};
typedef void (*zend_ini_parser_cb_t)(zval *arg1 , zval *arg2 , zval *arg3 ,
                                     int callback_type , void *arg );
struct _zend_ini_parser_param {
   void (*ini_parser_cb)(zval *arg1 , zval *arg2 , zval *arg3 ,
                         int callback_type , void *arg ) ;
   void *arg ;
};
typedef struct _zend_ini_parser_param zend_ini_parser_param;
struct utimbuf {
   __time_t actime ;
   __time_t modtime ;
};
struct dirent {
   __ino_t d_ino ;
   __off_t d_off ;
   unsigned short d_reclen ;
   unsigned char d_type ;
   char d_name[256] ;
};
struct dirent64 {
   __ino64_t d_ino ;
   __off64_t d_off ;
   unsigned short d_reclen ;
   unsigned char d_type ;
   char d_name[256] ;
};
enum __anonenum_79 {
    DT_UNKNOWN = 0,
    DT_FIFO = 1,
    DT_CHR = 2,
    DT_DIR = 4,
    DT_BLK = 6,
    DT_REG = 8,
    DT_LNK = 10,
    DT_SOCK = 12,
    DT_WHT = 14
} ;
struct __dirstream;
typedef struct __dirstream DIR;
struct _cwd_state {
   char *cwd ;
   int cwd_length ;
};
typedef struct _cwd_state cwd_state;
typedef int (*verify_path_func)(cwd_state const   * );
struct _realpath_cache_bucket {
   unsigned long key ;
   char *path ;
   int path_len ;
   char *realpath ;
   int realpath_len ;
   int is_dir ;
   time_t expires ;
   struct _realpath_cache_bucket *next ;
};
typedef struct _realpath_cache_bucket realpath_cache_bucket;
struct _virtual_cwd_globals {
   cwd_state cwd ;
   long realpath_cache_size ;
   long realpath_cache_size_limit ;
   long realpath_cache_ttl ;
   realpath_cache_bucket *realpath_cache[1024] ;
};
typedef struct _virtual_cwd_globals virtual_cwd_globals;
struct _zend_constant {
   zval value ;
   int flags ;
   char *name ;
   uint name_len ;
   int module_number ;
};
typedef struct _zend_constant zend_constant;
struct tm {
   int tm_sec ;
   int tm_min ;
   int tm_hour ;
   int tm_mday ;
   int tm_mon ;
   int tm_year ;
   int tm_wday ;
   int tm_yday ;
   int tm_isdst ;
   long tm_gmtoff ;
   char const   *tm_zone ;
};
struct itimerspec {
   struct timespec it_interval ;
   struct timespec it_value ;
};
struct sigevent;
struct __anonstruct_sapi_header_struct_80 {
   char *header ;
   uint header_len ;
};
typedef struct __anonstruct_sapi_header_struct_80 sapi_header_struct;
struct __anonstruct_sapi_headers_struct_81 {
   zend_llist headers ;
   int http_response_code ;
   unsigned char send_default_content_type ;
   char *mimetype ;
   char *http_status_line ;
};
typedef struct __anonstruct_sapi_headers_struct_81 sapi_headers_struct;
struct _sapi_post_entry;
typedef struct _sapi_post_entry sapi_post_entry;
struct _sapi_module_struct;
typedef struct _sapi_module_struct sapi_module_struct;
struct __anonstruct_sapi_request_info_82 {
   char const   *request_method ;
   char *query_string ;
   char *post_data ;
   char *raw_post_data ;
   char *cookie_data ;
   long content_length ;
   uint post_data_length ;
   uint raw_post_data_length ;
   char *path_translated ;
   char *request_uri ;
   char const   *content_type ;
   zend_bool headers_only ;
   zend_bool no_headers ;
   zend_bool headers_read ;
   sapi_post_entry *post_entry ;
   char *content_type_dup ;
   char *auth_user ;
   char *auth_password ;
   char *auth_digest ;
   char *argv0 ;
   char *current_user ;
   int current_user_length ;
   int argc ;
   char **argv ;
   int proto_num ;
};
typedef struct __anonstruct_sapi_request_info_82 sapi_request_info;
struct _sapi_globals_struct {
   void *server_context ;
   sapi_request_info request_info ;
   sapi_headers_struct sapi_headers ;
   int read_post_bytes ;
   unsigned char headers_sent ;
   struct stat global_stat ;
   char *default_mimetype ;
   char *default_charset ;
   HashTable *rfc1867_uploaded_files ;
   long post_max_size ;
   int options ;
   zend_bool sapi_started ;
   double global_request_time ;
   HashTable known_post_content_types ;
   zval *callback_func ;
   zend_fcall_info_cache fci_cache ;
   zend_bool callback_run ;
};
typedef struct _sapi_globals_struct sapi_globals_struct;
struct __anonstruct_sapi_header_line_83 {
   char *line ;
   uint line_len ;
   long response_code ;
};
typedef struct __anonstruct_sapi_header_line_83 sapi_header_line;
enum __anonenum_sapi_header_op_enum_84 {
    SAPI_HEADER_REPLACE = 0,
    SAPI_HEADER_ADD = 1,
    SAPI_HEADER_DELETE = 2,
    SAPI_HEADER_DELETE_ALL = 3,
    SAPI_HEADER_SET_STATUS = 4
} ;
typedef enum __anonenum_sapi_header_op_enum_84 sapi_header_op_enum;
struct _sapi_module_struct {
   char *name ;
   char *pretty_name ;
   int (*startup)(struct _sapi_module_struct *sapi_module ) ;
   int (*shutdown)(struct _sapi_module_struct *sapi_module ) ;
   int (*activate)(void) ;
   int (*deactivate)(void) ;
   int (*ub_write)(char const   *str , unsigned int str_length ) ;
   void (*flush)(void *server_context ) ;
   struct stat *(*get_stat)(void) ;
   char *(*getenv)(char *name , size_t name_len ) ;
   void (*sapi_error)(int type , char const   *error_msg  , ...) ;
   int (*header_handler)(sapi_header_struct *sapi_header ,
                         sapi_header_op_enum op ,
                         sapi_headers_struct *sapi_headers ) ;
   int (*send_headers)(sapi_headers_struct *sapi_headers ) ;
   void (*send_header)(sapi_header_struct *sapi_header , void *server_context ) ;
   int (*read_post)(char *buffer , uint count_bytes ) ;
   char *(*read_cookies)(void) ;
   void (*register_server_variables)(zval *track_vars_array ) ;
   void (*log_message)(char *message ) ;
   time_t (*get_request_time)(void) ;
   void (*terminate_process)(void) ;
   char *php_ini_path_override ;
   void (*block_interruptions)(void) ;
   void (*unblock_interruptions)(void) ;
   void (*default_post_reader)(void) ;
   void (*treat_data)(int arg , char *str , zval *destArray ) ;
   char *executable_location ;
   int php_ini_ignore ;
   int php_ini_ignore_cwd ;
   int (*get_fd)(int *fd ) ;
   int (*force_http_10)(void) ;
   int (*get_target_uid)(uid_t * ) ;
   int (*get_target_gid)(gid_t * ) ;
   unsigned int (*input_filter)(int arg , char *var , char **val ,
                                unsigned int val_len ,
                                unsigned int *new_val_len ) ;
   void (*ini_defaults)(HashTable *configuration_hash ) ;
   int phpinfo_as_text ;
   char *ini_entries ;
   zend_function_entry const   *additional_functions ;
   unsigned int (*input_filter_init)(void) ;
};
struct _sapi_post_entry {
   char *content_type ;
   uint content_type_len ;
   void (*post_reader)(void) ;
   void (*post_handler)(char *content_type_dup , void *arg ) ;
};
typedef unsigned int wint_t;
typedef __mbstate_t mbstate_t;
typedef int php_stat_len;
struct _zend_syntax_highlighter_ini {
   char *highlight_html ;
   char *highlight_comment ;
   char *highlight_default ;
   char *highlight_string ;
   char *highlight_keyword ;
};
typedef struct _zend_syntax_highlighter_ini zend_syntax_highlighter_ini;
struct __anonstruct_smart_str_85 {
   char *c ;
   size_t len ;
   size_t a ;
};
typedef struct __anonstruct_smart_str_85 smart_str;
struct __anonstruct_url_adapt_state_ex_t_86 {
   smart_str tag ;
   smart_str arg ;
   smart_str val ;
   smart_str buf ;
   smart_str result ;
   smart_str form_app ;
   smart_str url_app ;
   int active ;
   char *lookup_data ;
   int state ;
   HashTable *tags ;
};
typedef struct __anonstruct_url_adapt_state_ex_t_86 url_adapt_state_ex_t;
typedef unsigned int php_uint32;
typedef int php_int32;
struct __anonstruct_serialize_87 {
   void *var_hash ;
   unsigned int level ;
};
struct __anonstruct_unserialize_88 {
   void *var_hash ;
   unsigned int level ;
};
struct _php_basic_globals {
   HashTable *user_shutdown_function_names ;
   HashTable putenv_ht ;
   zval *strtok_zval ;
   char *strtok_string ;
   char *locale_string ;
   char *strtok_last ;
   char strtok_table[256] ;
   ulong strtok_len ;
   char str_ebuf[40] ;
   zend_fcall_info array_walk_fci ;
   zend_fcall_info_cache array_walk_fci_cache ;
   zend_fcall_info user_compare_fci ;
   zend_fcall_info_cache user_compare_fci_cache ;
   zend_llist *user_tick_functions ;
   zval *active_ini_file_section ;
   long page_uid ;
   long page_gid ;
   long page_inode ;
   time_t page_mtime ;
   char *CurrentStatFile ;
   char *CurrentLStatFile ;
   php_stream_statbuf ssb ;
   php_stream_statbuf lssb ;
   php_uint32 state[625] ;
   php_uint32 *next ;
   int left ;
   unsigned int rand_seed ;
   zend_bool rand_is_seeded ;
   zend_bool mt_rand_is_seeded ;
   char *syslog_device ;
   zend_class_entry *incomplete_class ;
   struct __anonstruct_serialize_87 serialize ;
   struct __anonstruct_unserialize_88 unserialize ;
   url_adapt_state_ex_t url_adapt_state_ex ;
   void *mmap_file ;
   size_t mmap_len ;
   HashTable *user_filter_map ;
   int umask ;
};
typedef struct _php_basic_globals php_basic_globals;
struct __anonstruct_putenv_entry_89 {
   char *putenv_string ;
   char *previous_value ;
   char *key ;
   int key_len ;
};
typedef struct __anonstruct_putenv_entry_89 putenv_entry;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef signed char int_least8_t;
typedef short int_least16_t;
typedef int int_least32_t;
typedef long long int_least64_t;
typedef unsigned char uint_least8_t;
typedef unsigned short uint_least16_t;
typedef unsigned int uint_least32_t;
typedef unsigned long long uint_least64_t;
typedef signed char int_fast8_t;
typedef int int_fast16_t;
typedef int int_fast32_t;
typedef long long int_fast64_t;
typedef unsigned char uint_fast8_t;
typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
typedef unsigned long long uint_fast64_t;
typedef unsigned int uintptr_t;
typedef long long intmax_t;
typedef unsigned long long uintmax_t;
typedef long __gwchar_t;
struct __anonstruct_imaxdiv_t_90 {
   long long quot ;
   long long rem ;
};
typedef struct __anonstruct_imaxdiv_t_90 imaxdiv_t;
typedef unsigned long long timelib_ull;
typedef long long timelib_sll;
struct ttinfo {
   int32_t offset ;
   int isdst ;
   unsigned int abbr_idx ;
   unsigned int isstdcnt ;
   unsigned int isgmtcnt ;
};
typedef struct ttinfo ttinfo;
struct tlinfo {
   int32_t trans ;
   int32_t offset ;
};
typedef struct tlinfo tlinfo;
struct tlocinfo {
   char country_code[3] ;
   double latitude ;
   double longitude ;
   char *comments ;
};
typedef struct tlocinfo tlocinfo;
struct timelib_tzinfo {
   char *name ;
   uint32_t ttisgmtcnt ;
   uint32_t ttisstdcnt ;
   uint32_t leapcnt ;
   uint32_t timecnt ;
   uint32_t typecnt ;
   uint32_t charcnt ;
   int32_t *trans ;
   unsigned char *trans_idx ;
   ttinfo *type ;
   char *timezone_abbr ;
   tlinfo *leap_times ;
   unsigned char bc ;
   tlocinfo location ;
};
typedef struct timelib_tzinfo timelib_tzinfo;
struct timelib_special {
   unsigned int type ;
   timelib_sll amount ;
};
typedef struct timelib_special timelib_special;
struct timelib_rel_time {
   timelib_sll y ;
   timelib_sll m ;
   timelib_sll d ;
   timelib_sll h ;
   timelib_sll i ;
   timelib_sll s ;
   int weekday ;
   int weekday_behavior ;
   int first_last_day_of ;
   int invert ;
   timelib_sll days ;
   timelib_special special ;
   unsigned int have_weekday_relative ;
   unsigned int have_special_relative ;
};
typedef struct timelib_rel_time timelib_rel_time;
struct timelib_time_offset {
   int32_t offset ;
   unsigned int leap_secs ;
   unsigned int is_dst ;
   char *abbr ;
   timelib_sll transistion_time ;
};
typedef struct timelib_time_offset timelib_time_offset;
struct timelib_time {
   timelib_sll y ;
   timelib_sll m ;
   timelib_sll d ;
   timelib_sll h ;
   timelib_sll i ;
   timelib_sll s ;
   double f ;
   int z ;
   char *tz_abbr ;
   timelib_tzinfo *tz_info ;
   int dst ;
   timelib_rel_time relative ;
   timelib_sll sse ;
   unsigned int have_time ;
   unsigned int have_date ;
   unsigned int have_zone ;
   unsigned int have_relative ;
   unsigned int have_weeknr_day ;
   unsigned int sse_uptodate ;
   unsigned int tim_uptodate ;
   unsigned int is_localtime ;
   unsigned int zone_type ;
};
typedef struct timelib_time timelib_time;
struct timelib_error_message {
   int position ;
   char character ;
   char *message ;
};
typedef struct timelib_error_message timelib_error_message;
struct timelib_error_container {
   int warning_count ;
   struct timelib_error_message *warning_messages ;
   int error_count ;
   struct timelib_error_message *error_messages ;
};
typedef struct timelib_error_container timelib_error_container;
struct _timelib_tz_lookup_table {
   char *name ;
   int type ;
   float gmtoffset ;
   char *full_tz_name ;
};
typedef struct _timelib_tz_lookup_table timelib_tz_lookup_table;
struct _timelib_tzdb_index_entry {
   char *id ;
   unsigned int pos ;
};
typedef struct _timelib_tzdb_index_entry timelib_tzdb_index_entry;
struct _timelib_tzdb {
   char *version ;
   int index_size ;
   timelib_tzdb_index_entry const   *index ;
   unsigned char const   *data ;
};
typedef struct _timelib_tzdb timelib_tzdb;
struct _php_date_obj;
typedef struct _php_date_obj php_date_obj;
struct _php_timezone_obj;
typedef struct _php_timezone_obj php_timezone_obj;
struct _php_interval_obj;
typedef struct _php_interval_obj php_interval_obj;
struct _php_period_obj;
typedef struct _php_period_obj php_period_obj;
struct _php_date_obj {
   zend_object std ;
   timelib_time *time ;
   HashTable *props ;
};
struct __anonstruct_z_92 {
   timelib_sll utc_offset ;
   char *abbr ;
   int dst ;
};
union __anonunion_tzi_91 {
   timelib_tzinfo *tz ;
   timelib_sll utc_offset ;
   struct __anonstruct_z_92 z ;
};
struct _php_timezone_obj {
   zend_object std ;
   int initialized ;
   int type ;
   union __anonunion_tzi_91 tzi ;
};
struct _php_interval_obj {
   zend_object std ;
   timelib_rel_time *diff ;
   HashTable *props ;
   int initialized ;
};
struct _php_period_obj {
   zend_object std ;
   timelib_time *start ;
   timelib_time *current ;
   timelib_time *end ;
   timelib_rel_time *interval ;
   int recurrences ;
   int initialized ;
   int include_start_date ;
};
struct _zend_date_globals {
   char *default_timezone ;
   char *timezone ;
   HashTable *tzcache ;
   timelib_error_container *last_errors ;
};
typedef struct _zend_date_globals zend_date_globals;
struct _zend_user_iterator {
   zend_object_iterator it ;
   zend_class_entry *ce ;
   zval *value ;
};
typedef struct _zend_user_iterator zend_user_iterator;
struct __anonstruct_date_period_it_93 {
   zend_object_iterator intern ;
   zval *date_period_zval ;
   zval *current ;
   php_period_obj *object ;
   int current_index ;
};
typedef struct __anonstruct_date_period_it_93 date_period_it;
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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1] == 0) {
    {
    fprintf(_coverage_fout, "1\n");
    fflush(_coverage_fout);
    ___coverage_array[1] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2] == 0) {
    {
    fprintf(_coverage_fout, "2\n");
    fflush(_coverage_fout);
    ___coverage_array[2] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3] == 0) {
    {
    fprintf(_coverage_fout, "3\n");
    fflush(_coverage_fout);
    ___coverage_array[3] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4] == 0) {
    {
    fprintf(_coverage_fout, "4\n");
    fflush(_coverage_fout);
    ___coverage_array[4] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5] == 0) {
    {
    fprintf(_coverage_fout, "5\n");
    fflush(_coverage_fout);
    ___coverage_array[5] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[6] == 0) {
    {
    fprintf(_coverage_fout, "6\n");
    fflush(_coverage_fout);
    ___coverage_array[6] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[7] == 0) {
    {
    fprintf(_coverage_fout, "7\n");
    fflush(_coverage_fout);
    ___coverage_array[7] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[8] == 0) {
    {
    fprintf(_coverage_fout, "8\n");
    fflush(_coverage_fout);
    ___coverage_array[8] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[9] == 0) {
    {
    fprintf(_coverage_fout, "9\n");
    fflush(_coverage_fout);
    ___coverage_array[9] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[10] == 0) {
    {
    fprintf(_coverage_fout, "10\n");
    fflush(_coverage_fout);
    ___coverage_array[10] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[11] == 0) {
    {
    fprintf(_coverage_fout, "11\n");
    fflush(_coverage_fout);
    ___coverage_array[11] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[16] == 0) {
    {
    fprintf(_coverage_fout, "16\n");
    fflush(_coverage_fout);
    ___coverage_array[16] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[17] == 0) {
    {
    fprintf(_coverage_fout, "17\n");
    fflush(_coverage_fout);
    ___coverage_array[17] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[14] == 0) {
      {
      fprintf(_coverage_fout, "14\n");
      fflush(_coverage_fout);
      ___coverage_array[14] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[13] == 0) {
        {
        fprintf(_coverage_fout, "13\n");
        fflush(_coverage_fout);
        ___coverage_array[13] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[12] == 0) {
          {
          fprintf(_coverage_fout, "12\n");
          fflush(_coverage_fout);
          ___coverage_array[12] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[15] == 0) {
      {
      fprintf(_coverage_fout, "15\n");
      fflush(_coverage_fout);
      ___coverage_array[15] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[18] == 0) {
    {
    fprintf(_coverage_fout, "18\n");
    fflush(_coverage_fout);
    ___coverage_array[18] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[24] == 0) {
    {
    fprintf(_coverage_fout, "24\n");
    fflush(_coverage_fout);
    ___coverage_array[24] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[25] == 0) {
    {
    fprintf(_coverage_fout, "25\n");
    fflush(_coverage_fout);
    ___coverage_array[25] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[22] == 0) {
      {
      fprintf(_coverage_fout, "22\n");
      fflush(_coverage_fout);
      ___coverage_array[22] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[21] == 0) {
        {
        fprintf(_coverage_fout, "21\n");
        fflush(_coverage_fout);
        ___coverage_array[21] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[20] == 0) {
          {
          fprintf(_coverage_fout, "20\n");
          fflush(_coverage_fout);
          ___coverage_array[20] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[19] == 0) {
            {
            fprintf(_coverage_fout, "19\n");
            fflush(_coverage_fout);
            ___coverage_array[19] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[23] == 0) {
      {
      fprintf(_coverage_fout, "23\n");
      fflush(_coverage_fout);
      ___coverage_array[23] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[26] == 0) {
    {
    fprintf(_coverage_fout, "26\n");
    fflush(_coverage_fout);
    ___coverage_array[26] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[33] == 0) {
    {
    fprintf(_coverage_fout, "33\n");
    fflush(_coverage_fout);
    ___coverage_array[33] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[34] == 0) {
    {
    fprintf(_coverage_fout, "34\n");
    fflush(_coverage_fout);
    ___coverage_array[34] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[31] == 0) {
      {
      fprintf(_coverage_fout, "31\n");
      fflush(_coverage_fout);
      ___coverage_array[31] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[30] == 0) {
        {
        fprintf(_coverage_fout, "30\n");
        fflush(_coverage_fout);
        ___coverage_array[30] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[29] == 0) {
          {
          fprintf(_coverage_fout, "29\n");
          fflush(_coverage_fout);
          ___coverage_array[29] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[28] == 0) {
            {
            fprintf(_coverage_fout, "28\n");
            fflush(_coverage_fout);
            ___coverage_array[28] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*(__s + __result) != (int const   )__reject3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[27] == 0) {
              {
              fprintf(_coverage_fout, "27\n");
              fflush(_coverage_fout);
              ___coverage_array[27] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[32] == 0) {
      {
      fprintf(_coverage_fout, "32\n");
      fflush(_coverage_fout);
      ___coverage_array[32] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[35] == 0) {
    {
    fprintf(_coverage_fout, "35\n");
    fflush(_coverage_fout);
    ___coverage_array[35] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[39] == 0) {
    {
    fprintf(_coverage_fout, "39\n");
    fflush(_coverage_fout);
    ___coverage_array[39] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[40] == 0) {
    {
    fprintf(_coverage_fout, "40\n");
    fflush(_coverage_fout);
    ___coverage_array[40] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[37] == 0) {
      {
      fprintf(_coverage_fout, "37\n");
      fflush(_coverage_fout);
      ___coverage_array[37] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[36] == 0) {
        {
        fprintf(_coverage_fout, "36\n");
        fflush(_coverage_fout);
        ___coverage_array[36] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[38] == 0) {
      {
      fprintf(_coverage_fout, "38\n");
      fflush(_coverage_fout);
      ___coverage_array[38] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[41] == 0) {
    {
    fprintf(_coverage_fout, "41\n");
    fflush(_coverage_fout);
    ___coverage_array[41] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[47] == 0) {
    {
    fprintf(_coverage_fout, "47\n");
    fflush(_coverage_fout);
    ___coverage_array[47] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[48] == 0) {
    {
    fprintf(_coverage_fout, "48\n");
    fflush(_coverage_fout);
    ___coverage_array[48] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[45] == 0) {
      {
      fprintf(_coverage_fout, "45\n");
      fflush(_coverage_fout);
      ___coverage_array[45] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[42] == 0) {
        {
        fprintf(_coverage_fout, "42\n");
        fflush(_coverage_fout);
        ___coverage_array[42] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[44] == 0) {
        {
        fprintf(_coverage_fout, "44\n");
        fflush(_coverage_fout);
        ___coverage_array[44] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) == (int const   )__accept2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[43] == 0) {
          {
          fprintf(_coverage_fout, "43\n");
          fflush(_coverage_fout);
          ___coverage_array[43] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[46] == 0) {
      {
      fprintf(_coverage_fout, "46\n");
      fflush(_coverage_fout);
      ___coverage_array[46] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[49] == 0) {
    {
    fprintf(_coverage_fout, "49\n");
    fflush(_coverage_fout);
    ___coverage_array[49] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[57] == 0) {
    {
    fprintf(_coverage_fout, "57\n");
    fflush(_coverage_fout);
    ___coverage_array[57] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (size_t )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[58] == 0) {
    {
    fprintf(_coverage_fout, "58\n");
    fflush(_coverage_fout);
    ___coverage_array[58] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[55] == 0) {
      {
      fprintf(_coverage_fout, "55\n");
      fflush(_coverage_fout);
      ___coverage_array[55] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[50] == 0) {
        {
        fprintf(_coverage_fout, "50\n");
        fflush(_coverage_fout);
        ___coverage_array[50] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[54] == 0) {
        {
        fprintf(_coverage_fout, "54\n");
        fflush(_coverage_fout);
        ___coverage_array[54] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(__s + __result) == (int const   )__accept2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[51] == 0) {
          {
          fprintf(_coverage_fout, "51\n");
          fflush(_coverage_fout);
          ___coverage_array[51] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[53] == 0) {
          {
          fprintf(_coverage_fout, "53\n");
          fflush(_coverage_fout);
          ___coverage_array[53] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(__s + __result) == (int const   )__accept3) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[52] == 0) {
            {
            fprintf(_coverage_fout, "52\n");
            fflush(_coverage_fout);
            ___coverage_array[52] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[56] == 0) {
      {
      fprintf(_coverage_fout, "56\n");
      fflush(_coverage_fout);
      ___coverage_array[56] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[59] == 0) {
    {
    fprintf(_coverage_fout, "59\n");
    fflush(_coverage_fout);
    ___coverage_array[59] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[67] == 0) {
    {
    fprintf(_coverage_fout, "67\n");
    fflush(_coverage_fout);
    ___coverage_array[67] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[63] == 0) {
      {
      fprintf(_coverage_fout, "63\n");
      fflush(_coverage_fout);
      ___coverage_array[63] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[62] == 0) {
        {
        fprintf(_coverage_fout, "62\n");
        fflush(_coverage_fout);
        ___coverage_array[62] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[61] == 0) {
          {
          fprintf(_coverage_fout, "61\n");
          fflush(_coverage_fout);
          ___coverage_array[61] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[60] == 0) {
            {
            fprintf(_coverage_fout, "60\n");
            fflush(_coverage_fout);
            ___coverage_array[60] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[64] == 0) {
      {
      fprintf(_coverage_fout, "64\n");
      fflush(_coverage_fout);
      ___coverage_array[64] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[68] == 0) {
    {
    fprintf(_coverage_fout, "68\n");
    fflush(_coverage_fout);
    ___coverage_array[68] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[65] == 0) {
      {
      fprintf(_coverage_fout, "65\n");
      fflush(_coverage_fout);
      ___coverage_array[65] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[66] == 0) {
      {
      fprintf(_coverage_fout, "66\n");
      fflush(_coverage_fout);
      ___coverage_array[66] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[69] == 0) {
    {
    fprintf(_coverage_fout, "69\n");
    fflush(_coverage_fout);
    ___coverage_array[69] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[78] == 0) {
    {
    fprintf(_coverage_fout, "78\n");
    fflush(_coverage_fout);
    ___coverage_array[78] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[74] == 0) {
      {
      fprintf(_coverage_fout, "74\n");
      fflush(_coverage_fout);
      ___coverage_array[74] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[73] == 0) {
        {
        fprintf(_coverage_fout, "73\n");
        fflush(_coverage_fout);
        ___coverage_array[73] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[72] == 0) {
          {
          fprintf(_coverage_fout, "72\n");
          fflush(_coverage_fout);
          ___coverage_array[72] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[71] == 0) {
            {
            fprintf(_coverage_fout, "71\n");
            fflush(_coverage_fout);
            ___coverage_array[71] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*__s != (int const   )__accept3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[70] == 0) {
              {
              fprintf(_coverage_fout, "70\n");
              fflush(_coverage_fout);
              ___coverage_array[70] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[75] == 0) {
      {
      fprintf(_coverage_fout, "75\n");
      fflush(_coverage_fout);
      ___coverage_array[75] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[79] == 0) {
    {
    fprintf(_coverage_fout, "79\n");
    fflush(_coverage_fout);
    ___coverage_array[79] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[76] == 0) {
      {
      fprintf(_coverage_fout, "76\n");
      fflush(_coverage_fout);
      ___coverage_array[76] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[77] == 0) {
      {
      fprintf(_coverage_fout, "77\n");
      fflush(_coverage_fout);
      ___coverage_array[77] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[80] == 0) {
    {
    fprintf(_coverage_fout, "80\n");
    fflush(_coverage_fout);
    ___coverage_array[80] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[98] == 0) {
    {
    fprintf(_coverage_fout, "98\n");
    fflush(_coverage_fout);
    ___coverage_array[98] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__s == (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[81] == 0) {
      {
      fprintf(_coverage_fout, "81\n");
      fflush(_coverage_fout);
      ___coverage_array[81] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = *__nextp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[82] == 0) {
      {
      fprintf(_coverage_fout, "82\n");
      fflush(_coverage_fout);
      ___coverage_array[82] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[99] == 0) {
    {
    fprintf(_coverage_fout, "99\n");
    fflush(_coverage_fout);
    ___coverage_array[99] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[84] == 0) {
      {
      fprintf(_coverage_fout, "84\n");
      fflush(_coverage_fout);
      ___coverage_array[84] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )*__s == (int )__sep) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[83] == 0) {
        {
        fprintf(_coverage_fout, "83\n");
        fflush(_coverage_fout);
        ___coverage_array[83] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[85] == 0) {
      {
      fprintf(_coverage_fout, "85\n");
      fflush(_coverage_fout);
      ___coverage_array[85] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[100] == 0) {
    {
    fprintf(_coverage_fout, "100\n");
    fflush(_coverage_fout);
    ___coverage_array[100] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __result = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[101] == 0) {
    {
    fprintf(_coverage_fout, "101\n");
    fflush(_coverage_fout);
    ___coverage_array[101] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )*__s != 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[93] == 0) {
      {
      fprintf(_coverage_fout, "93\n");
      fflush(_coverage_fout);
      ___coverage_array[93] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = __s;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[94] == 0) {
      {
      fprintf(_coverage_fout, "94\n");
      fflush(_coverage_fout);
      ___coverage_array[94] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[95] == 0) {
      {
      fprintf(_coverage_fout, "95\n");
      fflush(_coverage_fout);
      ___coverage_array[95] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __result = tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[96] == 0) {
      {
      fprintf(_coverage_fout, "96\n");
      fflush(_coverage_fout);
      ___coverage_array[96] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[89] == 0) {
        {
        fprintf(_coverage_fout, "89\n");
        fflush(_coverage_fout);
        ___coverage_array[89] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__s != 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[86] == 0) {
          {
          fprintf(_coverage_fout, "86\n");
          fflush(_coverage_fout);
          ___coverage_array[86] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[90] == 0) {
        {
        fprintf(_coverage_fout, "90\n");
        fflush(_coverage_fout);
        ___coverage_array[90] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = __s;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[91] == 0) {
        {
        fprintf(_coverage_fout, "91\n");
        fflush(_coverage_fout);
        ___coverage_array[91] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s ++;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[92] == 0) {
        {
        fprintf(_coverage_fout, "92\n");
        fflush(_coverage_fout);
        ___coverage_array[92] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*tmp___0 == (int )__sep) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[87] == 0) {
          {
          fprintf(_coverage_fout, "87\n");
          fflush(_coverage_fout);
          ___coverage_array[87] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *(__s + -1) = (char )'\000';
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[88] == 0) {
          {
          fprintf(_coverage_fout, "88\n");
          fflush(_coverage_fout);
          ___coverage_array[88] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[97] == 0) {
      {
      fprintf(_coverage_fout, "97\n");
      fflush(_coverage_fout);
      ___coverage_array[97] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[102] == 0) {
    {
    fprintf(_coverage_fout, "102\n");
    fflush(_coverage_fout);
    ___coverage_array[102] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *__nextp = __s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[103] == 0) {
    {
    fprintf(_coverage_fout, "103\n");
    fflush(_coverage_fout);
    ___coverage_array[103] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[113] == 0) {
    {
    fprintf(_coverage_fout, "113\n");
    fflush(_coverage_fout);
    ___coverage_array[113] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __retval = *__s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[114] == 0) {
    {
    fprintf(_coverage_fout, "114\n");
    fflush(_coverage_fout);
    ___coverage_array[114] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[108] == 0) {
      {
      fprintf(_coverage_fout, "108\n");
      fflush(_coverage_fout);
      ___coverage_array[108] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = __builtin_strchr(__retval, (int )__reject);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[109] == 0) {
      {
      fprintf(_coverage_fout, "109\n");
      fflush(_coverage_fout);
      ___coverage_array[109] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[110] == 0) {
      {
      fprintf(_coverage_fout, "110\n");
      fflush(_coverage_fout);
      ___coverage_array[110] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__s = tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[111] == 0) {
      {
      fprintf(_coverage_fout, "111\n");
      fflush(_coverage_fout);
      ___coverage_array[111] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[104] == 0) {
        {
        fprintf(_coverage_fout, "104\n");
        fflush(_coverage_fout);
        ___coverage_array[104] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = *__s;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[105] == 0) {
        {
        fprintf(_coverage_fout, "105\n");
        fflush(_coverage_fout);
        ___coverage_array[105] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (*__s) ++;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[106] == 0) {
        {
        fprintf(_coverage_fout, "106\n");
        fflush(_coverage_fout);
        ___coverage_array[106] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *tmp = (char )'\000';
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[107] == 0) {
        {
        fprintf(_coverage_fout, "107\n");
        fflush(_coverage_fout);
        ___coverage_array[107] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[112] == 0) {
      {
      fprintf(_coverage_fout, "112\n");
      fflush(_coverage_fout);
      ___coverage_array[112] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[115] == 0) {
    {
    fprintf(_coverage_fout, "115\n");
    fflush(_coverage_fout);
    ___coverage_array[115] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[133] == 0) {
    {
    fprintf(_coverage_fout, "133\n");
    fflush(_coverage_fout);
    ___coverage_array[133] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __retval = *__s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[134] == 0) {
    {
    fprintf(_coverage_fout, "134\n");
    fflush(_coverage_fout);
    ___coverage_array[134] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[129] == 0) {
      {
      fprintf(_coverage_fout, "129\n");
      fflush(_coverage_fout);
      ___coverage_array[129] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __cp = __retval;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[130] == 0) {
      {
      fprintf(_coverage_fout, "130\n");
      fflush(_coverage_fout);
      ___coverage_array[130] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[126] == 0) {
        {
        fprintf(_coverage_fout, "126\n");
        fflush(_coverage_fout);
        ___coverage_array[126] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[116] == 0) {
          {
          fprintf(_coverage_fout, "116\n");
          fflush(_coverage_fout);
          ___coverage_array[116] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[117] == 0) {
          {
          fprintf(_coverage_fout, "117\n");
          fflush(_coverage_fout);
          ___coverage_array[117] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[127] == 0) {
        {
        fprintf(_coverage_fout, "127\n");
        fflush(_coverage_fout);
        ___coverage_array[127] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[118] == 0) {
          {
          fprintf(_coverage_fout, "118\n");
          fflush(_coverage_fout);
          ___coverage_array[118] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __cp;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[119] == 0) {
          {
          fprintf(_coverage_fout, "119\n");
          fflush(_coverage_fout);
          ___coverage_array[119] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[120] == 0) {
          {
          fprintf(_coverage_fout, "120\n");
          fflush(_coverage_fout);
          ___coverage_array[120] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[125] == 0) {
          {
          fprintf(_coverage_fout, "125\n");
          fflush(_coverage_fout);
          ___coverage_array[125] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[121] == 0) {
            {
            fprintf(_coverage_fout, "121\n");
            fflush(_coverage_fout);
            ___coverage_array[121] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp = __cp;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[122] == 0) {
            {
            fprintf(_coverage_fout, "122\n");
            fflush(_coverage_fout);
            ___coverage_array[122] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __cp ++;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[123] == 0) {
            {
            fprintf(_coverage_fout, "123\n");
            fflush(_coverage_fout);
            ___coverage_array[123] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[124] == 0) {
            {
            fprintf(_coverage_fout, "124\n");
            fflush(_coverage_fout);
            ___coverage_array[124] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[128] == 0) {
        {
        fprintf(_coverage_fout, "128\n");
        fflush(_coverage_fout);
        ___coverage_array[128] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __cp ++;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[131] == 0) {
      {
      fprintf(_coverage_fout, "131\n");
      fflush(_coverage_fout);
      ___coverage_array[131] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[132] == 0) {
      {
      fprintf(_coverage_fout, "132\n");
      fflush(_coverage_fout);
      ___coverage_array[132] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[135] == 0) {
    {
    fprintf(_coverage_fout, "135\n");
    fflush(_coverage_fout);
    ___coverage_array[135] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[157] == 0) {
    {
    fprintf(_coverage_fout, "157\n");
    fflush(_coverage_fout);
    ___coverage_array[157] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __retval = *__s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[158] == 0) {
    {
    fprintf(_coverage_fout, "158\n");
    fflush(_coverage_fout);
    ___coverage_array[158] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[153] == 0) {
      {
      fprintf(_coverage_fout, "153\n");
      fflush(_coverage_fout);
      ___coverage_array[153] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __cp = __retval;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[154] == 0) {
      {
      fprintf(_coverage_fout, "154\n");
      fflush(_coverage_fout);
      ___coverage_array[154] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[150] == 0) {
        {
        fprintf(_coverage_fout, "150\n");
        fflush(_coverage_fout);
        ___coverage_array[150] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[136] == 0) {
          {
          fprintf(_coverage_fout, "136\n");
          fflush(_coverage_fout);
          ___coverage_array[136] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[137] == 0) {
          {
          fprintf(_coverage_fout, "137\n");
          fflush(_coverage_fout);
          ___coverage_array[137] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[151] == 0) {
        {
        fprintf(_coverage_fout, "151\n");
        fflush(_coverage_fout);
        ___coverage_array[151] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[138] == 0) {
          {
          fprintf(_coverage_fout, "138\n");
          fflush(_coverage_fout);
          ___coverage_array[138] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = __cp;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[139] == 0) {
          {
          fprintf(_coverage_fout, "139\n");
          fflush(_coverage_fout);
          ___coverage_array[139] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __cp ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[140] == 0) {
          {
          fprintf(_coverage_fout, "140\n");
          fflush(_coverage_fout);
          ___coverage_array[140] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[149] == 0) {
          {
          fprintf(_coverage_fout, "149\n");
          fflush(_coverage_fout);
          ___coverage_array[149] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[141] == 0) {
            {
            fprintf(_coverage_fout, "141\n");
            fflush(_coverage_fout);
            ___coverage_array[141] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp = __cp;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[142] == 0) {
            {
            fprintf(_coverage_fout, "142\n");
            fflush(_coverage_fout);
            ___coverage_array[142] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __cp ++;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[143] == 0) {
            {
            fprintf(_coverage_fout, "143\n");
            fflush(_coverage_fout);
            ___coverage_array[143] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[148] == 0) {
            {
            fprintf(_coverage_fout, "148\n");
            fflush(_coverage_fout);
            ___coverage_array[148] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int )*__cp == (int )__reject3) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[144] == 0) {
              {
              fprintf(_coverage_fout, "144\n");
              fflush(_coverage_fout);
              ___coverage_array[144] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp = __cp;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[145] == 0) {
              {
              fprintf(_coverage_fout, "145\n");
              fflush(_coverage_fout);
              ___coverage_array[145] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __cp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[146] == 0) {
              {
              fprintf(_coverage_fout, "146\n");
              fflush(_coverage_fout);
              ___coverage_array[146] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *tmp = (char )'\000';
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[147] == 0) {
              {
              fprintf(_coverage_fout, "147\n");
              fflush(_coverage_fout);
              ___coverage_array[147] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[152] == 0) {
        {
        fprintf(_coverage_fout, "152\n");
        fflush(_coverage_fout);
        ___coverage_array[152] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __cp ++;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[155] == 0) {
      {
      fprintf(_coverage_fout, "155\n");
      fflush(_coverage_fout);
      ___coverage_array[155] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[156] == 0) {
      {
      fprintf(_coverage_fout, "156\n");
      fflush(_coverage_fout);
      ___coverage_array[156] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[159] == 0) {
    {
    fprintf(_coverage_fout, "159\n");
    fflush(_coverage_fout);
    ___coverage_array[159] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[160] == 0) {
    {
    fprintf(_coverage_fout, "160\n");
    fflush(_coverage_fout);
    ___coverage_array[160] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __u.__f = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[161] == 0) {
    {
    fprintf(_coverage_fout, "161\n");
    fflush(_coverage_fout);
    ___coverage_array[161] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[162] == 0) {
    {
    fprintf(_coverage_fout, "162\n");
    fflush(_coverage_fout);
    ___coverage_array[162] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __u.__d = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[163] == 0) {
    {
    fprintf(_coverage_fout, "163\n");
    fflush(_coverage_fout);
    ___coverage_array[163] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[164] == 0) {
    {
    fprintf(_coverage_fout, "164\n");
    fflush(_coverage_fout);
    ___coverage_array[164] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __u.__l = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[165] == 0) {
    {
    fprintf(_coverage_fout, "165\n");
    fflush(_coverage_fout);
    ___coverage_array[165] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[171] == 0) {
    {
    fprintf(_coverage_fout, "171\n");
    fflush(_coverage_fout);
    ___coverage_array[171] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__x == 0.0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[166] == 0) {
      {
      fprintf(_coverage_fout, "166\n");
      fflush(_coverage_fout);
      ___coverage_array[166] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[169] == 0) {
      {
      fprintf(_coverage_fout, "169\n");
      fflush(_coverage_fout);
      ___coverage_array[169] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (__x > 0.0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[167] == 0) {
        {
        fprintf(_coverage_fout, "167\n");
        fflush(_coverage_fout);
        ___coverage_array[167] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[168] == 0) {
        {
        fprintf(_coverage_fout, "168\n");
        fflush(_coverage_fout);
        ___coverage_array[168] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[170] == 0) {
      {
      fprintf(_coverage_fout, "170\n");
      fflush(_coverage_fout);
      ___coverage_array[170] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[172] == 0) {
    {
    fprintf(_coverage_fout, "172\n");
    fflush(_coverage_fout);
    ___coverage_array[172] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[178] == 0) {
    {
    fprintf(_coverage_fout, "178\n");
    fflush(_coverage_fout);
    ___coverage_array[178] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((double )__x == 0.0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[173] == 0) {
      {
      fprintf(_coverage_fout, "173\n");
      fflush(_coverage_fout);
      ___coverage_array[173] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[176] == 0) {
      {
      fprintf(_coverage_fout, "176\n");
      fflush(_coverage_fout);
      ___coverage_array[176] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((double )__x > 0.0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[174] == 0) {
        {
        fprintf(_coverage_fout, "174\n");
        fflush(_coverage_fout);
        ___coverage_array[174] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[175] == 0) {
        {
        fprintf(_coverage_fout, "175\n");
        fflush(_coverage_fout);
        ___coverage_array[175] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[177] == 0) {
      {
      fprintf(_coverage_fout, "177\n");
      fflush(_coverage_fout);
      ___coverage_array[177] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[179] == 0) {
    {
    fprintf(_coverage_fout, "179\n");
    fflush(_coverage_fout);
    ___coverage_array[179] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[185] == 0) {
    {
    fprintf(_coverage_fout, "185\n");
    fflush(_coverage_fout);
    ___coverage_array[185] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__x == (long double )0.0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[180] == 0) {
      {
      fprintf(_coverage_fout, "180\n");
      fflush(_coverage_fout);
      ___coverage_array[180] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[183] == 0) {
      {
      fprintf(_coverage_fout, "183\n");
      fflush(_coverage_fout);
      ___coverage_array[183] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (__x > (long double )0.0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[181] == 0) {
        {
        fprintf(_coverage_fout, "181\n");
        fflush(_coverage_fout);
        ___coverage_array[181] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[182] == 0) {
        {
        fprintf(_coverage_fout, "182\n");
        fflush(_coverage_fout);
        ___coverage_array[182] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[184] == 0) {
      {
      fprintf(_coverage_fout, "184\n");
      fflush(_coverage_fout);
      ___coverage_array[184] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[186] == 0) {
    {
    fprintf(_coverage_fout, "186\n");
    fflush(_coverage_fout);
    ___coverage_array[186] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[187] == 0) {
    {
    fprintf(_coverage_fout, "187\n");
    fflush(_coverage_fout);
    ___coverage_array[187] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_atan2l(__y, __x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[188] == 0) {
    {
    fprintf(_coverage_fout, "188\n");
    fflush(_coverage_fout);
    ___coverage_array[188] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[189] == 0) {
    {
    fprintf(_coverage_fout, "189\n");
    fflush(_coverage_fout);
    ___coverage_array[189] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabs(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[190] == 0) {
    {
    fprintf(_coverage_fout, "190\n");
    fflush(_coverage_fout);
    ___coverage_array[190] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[191] == 0) {
    {
    fprintf(_coverage_fout, "191\n");
    fflush(_coverage_fout);
    ___coverage_array[191] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabsf(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[192] == 0) {
    {
    fprintf(_coverage_fout, "192\n");
    fflush(_coverage_fout);
    ___coverage_array[192] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[193] == 0) {
    {
    fprintf(_coverage_fout, "193\n");
    fflush(_coverage_fout);
    ___coverage_array[193] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[194] == 0) {
    {
    fprintf(_coverage_fout, "194\n");
    fflush(_coverage_fout);
    ___coverage_array[194] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[195] == 0) {
    {
    fprintf(_coverage_fout, "195\n");
    fflush(_coverage_fout);
    ___coverage_array[195] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[196] == 0) {
    {
    fprintf(_coverage_fout, "196\n");
    fflush(_coverage_fout);
    ___coverage_array[196] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[197] == 0) {
    {
    fprintf(_coverage_fout, "197\n");
    fflush(_coverage_fout);
    ___coverage_array[197] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xld = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[198] == 0) {
    {
    fprintf(_coverage_fout, "198\n");
    fflush(_coverage_fout);
    ___coverage_array[198] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xi[2] = (__n.__xi[2] & 32768U) | 16383U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[199] == 0) {
    {
    fprintf(_coverage_fout, "199\n");
    fflush(_coverage_fout);
    ___coverage_array[199] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xi[1] = 0x80000000;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[200] == 0) {
    {
    fprintf(_coverage_fout, "200\n");
    fflush(_coverage_fout);
    ___coverage_array[200] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __n.__xi[0] = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[201] == 0) {
    {
    fprintf(_coverage_fout, "201\n");
    fflush(_coverage_fout);
    ___coverage_array[201] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[202] == 0) {
    {
    fprintf(_coverage_fout, "202\n");
    fflush(_coverage_fout);
    ___coverage_array[202] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[203] == 0) {
    {
    fprintf(_coverage_fout, "203\n");
    fflush(_coverage_fout);
    ___coverage_array[203] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[204] == 0) {
    {
    fprintf(_coverage_fout, "204\n");
    fflush(_coverage_fout);
    ___coverage_array[204] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[205] == 0) {
    {
    fprintf(_coverage_fout, "205\n");
    fflush(_coverage_fout);
    ___coverage_array[205] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[206] == 0) {
    {
    fprintf(_coverage_fout, "206\n");
    fflush(_coverage_fout);
    ___coverage_array[206] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[207] == 0) {
    {
    fprintf(_coverage_fout, "207\n");
    fflush(_coverage_fout);
    ___coverage_array[207] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[208] == 0) {
    {
    fprintf(_coverage_fout, "208\n");
    fflush(_coverage_fout);
    ___coverage_array[208] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[209] == 0) {
    {
    fprintf(_coverage_fout, "209\n");
    fflush(_coverage_fout);
    ___coverage_array[209] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[210] == 0) {
    {
    fprintf(_coverage_fout, "210\n");
    fflush(_coverage_fout);
    ___coverage_array[210] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[211] == 0) {
    {
    fprintf(_coverage_fout, "211\n");
    fflush(_coverage_fout);
    ___coverage_array[211] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[212] == 0) {
    {
    fprintf(_coverage_fout, "212\n");
    fflush(_coverage_fout);
    ___coverage_array[212] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[213] == 0) {
    {
    fprintf(_coverage_fout, "213\n");
    fflush(_coverage_fout);
    ___coverage_array[213] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[214] == 0) {
    {
    fprintf(_coverage_fout, "214\n");
    fflush(_coverage_fout);
    ___coverage_array[214] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[215] == 0) {
    {
    fprintf(_coverage_fout, "215\n");
    fflush(_coverage_fout);
    ___coverage_array[215] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[216] == 0) {
    {
    fprintf(_coverage_fout, "216\n");
    fflush(_coverage_fout);
    ___coverage_array[216] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[217] == 0) {
    {
    fprintf(_coverage_fout, "217\n");
    fflush(_coverage_fout);
    ___coverage_array[217] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[218] == 0) {
    {
    fprintf(_coverage_fout, "218\n");
    fflush(_coverage_fout);
    ___coverage_array[218] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[219] == 0) {
    {
    fprintf(_coverage_fout, "219\n");
    fflush(_coverage_fout);
    ___coverage_array[219] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[220] == 0) {
    {
    fprintf(_coverage_fout, "220\n");
    fflush(_coverage_fout);
    ___coverage_array[220] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[221] == 0) {
    {
    fprintf(_coverage_fout, "221\n");
    fflush(_coverage_fout);
    ___coverage_array[221] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[222] == 0) {
    {
    fprintf(_coverage_fout, "222\n");
    fflush(_coverage_fout);
    ___coverage_array[222] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[223] == 0) {
    {
    fprintf(_coverage_fout, "223\n");
    fflush(_coverage_fout);
    ___coverage_array[223] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[224] == 0) {
    {
    fprintf(_coverage_fout, "224\n");
    fflush(_coverage_fout);
    ___coverage_array[224] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[225] == 0) {
    {
    fprintf(_coverage_fout, "225\n");
    fflush(_coverage_fout);
    ___coverage_array[225] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[226] == 0) {
    {
    fprintf(_coverage_fout, "226\n");
    fflush(_coverage_fout);
    ___coverage_array[226] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __constr_expr_0.__d = __x;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[227] == 0) {
    {
    fprintf(_coverage_fout, "227\n");
    fflush(_coverage_fout);
    ___coverage_array[227] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[228] == 0) {
    {
    fprintf(_coverage_fout, "228\n");
    fflush(_coverage_fout);
    ___coverage_array[228] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = vfprintf((FILE */* __restrict  */)stdout, __fmt, __arg);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[229] == 0) {
    {
    fprintf(_coverage_fout, "229\n");
    fflush(_coverage_fout);
    ___coverage_array[229] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[230] == 0) {
    {
    fprintf(_coverage_fout, "230\n");
    fflush(_coverage_fout);
    ___coverage_array[230] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _IO_getc(stdin);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[231] == 0) {
    {
    fprintf(_coverage_fout, "231\n");
    fflush(_coverage_fout);
    ___coverage_array[231] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[237] == 0) {
    {
    fprintf(_coverage_fout, "237\n");
    fflush(_coverage_fout);
    ___coverage_array[237] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[238] == 0) {
    {
    fprintf(_coverage_fout, "238\n");
    fflush(_coverage_fout);
    ___coverage_array[238] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[232] == 0) {
      {
      fprintf(_coverage_fout, "232\n");
      fflush(_coverage_fout);
      ___coverage_array[232] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[233] == 0) {
      {
      fprintf(_coverage_fout, "233\n");
      fflush(_coverage_fout);
      ___coverage_array[233] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[234] == 0) {
      {
      fprintf(_coverage_fout, "234\n");
      fflush(_coverage_fout);
      ___coverage_array[234] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[235] == 0) {
      {
      fprintf(_coverage_fout, "235\n");
      fflush(_coverage_fout);
      ___coverage_array[235] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[236] == 0) {
      {
      fprintf(_coverage_fout, "236\n");
      fflush(_coverage_fout);
      ___coverage_array[236] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[239] == 0) {
    {
    fprintf(_coverage_fout, "239\n");
    fflush(_coverage_fout);
    ___coverage_array[239] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[245] == 0) {
    {
    fprintf(_coverage_fout, "245\n");
    fflush(_coverage_fout);
    ___coverage_array[245] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[246] == 0) {
    {
    fprintf(_coverage_fout, "246\n");
    fflush(_coverage_fout);
    ___coverage_array[246] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[240] == 0) {
      {
      fprintf(_coverage_fout, "240\n");
      fflush(_coverage_fout);
      ___coverage_array[240] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[241] == 0) {
      {
      fprintf(_coverage_fout, "241\n");
      fflush(_coverage_fout);
      ___coverage_array[241] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[242] == 0) {
      {
      fprintf(_coverage_fout, "242\n");
      fflush(_coverage_fout);
      ___coverage_array[242] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[243] == 0) {
      {
      fprintf(_coverage_fout, "243\n");
      fflush(_coverage_fout);
      ___coverage_array[243] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[244] == 0) {
      {
      fprintf(_coverage_fout, "244\n");
      fflush(_coverage_fout);
      ___coverage_array[244] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[247] == 0) {
    {
    fprintf(_coverage_fout, "247\n");
    fflush(_coverage_fout);
    ___coverage_array[247] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[253] == 0) {
    {
    fprintf(_coverage_fout, "253\n");
    fflush(_coverage_fout);
    ___coverage_array[253] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[254] == 0) {
    {
    fprintf(_coverage_fout, "254\n");
    fflush(_coverage_fout);
    ___coverage_array[254] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[248] == 0) {
      {
      fprintf(_coverage_fout, "248\n");
      fflush(_coverage_fout);
      ___coverage_array[248] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __uflow(stdin);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[249] == 0) {
      {
      fprintf(_coverage_fout, "249\n");
      fflush(_coverage_fout);
      ___coverage_array[249] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[250] == 0) {
      {
      fprintf(_coverage_fout, "250\n");
      fflush(_coverage_fout);
      ___coverage_array[250] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = stdin->_IO_read_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[251] == 0) {
      {
      fprintf(_coverage_fout, "251\n");
      fflush(_coverage_fout);
      ___coverage_array[251] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (stdin->_IO_read_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[252] == 0) {
      {
      fprintf(_coverage_fout, "252\n");
      fflush(_coverage_fout);
      ___coverage_array[252] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[255] == 0) {
    {
    fprintf(_coverage_fout, "255\n");
    fflush(_coverage_fout);
    ___coverage_array[255] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[256] == 0) {
    {
    fprintf(_coverage_fout, "256\n");
    fflush(_coverage_fout);
    ___coverage_array[256] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _IO_putc(__c, stdout);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[257] == 0) {
    {
    fprintf(_coverage_fout, "257\n");
    fflush(_coverage_fout);
    ___coverage_array[257] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[265] == 0) {
    {
    fprintf(_coverage_fout, "265\n");
    fflush(_coverage_fout);
    ___coverage_array[265] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[266] == 0) {
    {
    fprintf(_coverage_fout, "266\n");
    fflush(_coverage_fout);
    ___coverage_array[266] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[258] == 0) {
      {
      fprintf(_coverage_fout, "258\n");
      fflush(_coverage_fout);
      ___coverage_array[258] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[259] == 0) {
      {
      fprintf(_coverage_fout, "259\n");
      fflush(_coverage_fout);
      ___coverage_array[259] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[260] == 0) {
      {
      fprintf(_coverage_fout, "260\n");
      fflush(_coverage_fout);
      ___coverage_array[260] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[261] == 0) {
      {
      fprintf(_coverage_fout, "261\n");
      fflush(_coverage_fout);
      ___coverage_array[261] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[262] == 0) {
      {
      fprintf(_coverage_fout, "262\n");
      fflush(_coverage_fout);
      ___coverage_array[262] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[263] == 0) {
      {
      fprintf(_coverage_fout, "263\n");
      fflush(_coverage_fout);
      ___coverage_array[263] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[264] == 0) {
      {
      fprintf(_coverage_fout, "264\n");
      fflush(_coverage_fout);
      ___coverage_array[264] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[267] == 0) {
    {
    fprintf(_coverage_fout, "267\n");
    fflush(_coverage_fout);
    ___coverage_array[267] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[275] == 0) {
    {
    fprintf(_coverage_fout, "275\n");
    fflush(_coverage_fout);
    ___coverage_array[275] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[276] == 0) {
    {
    fprintf(_coverage_fout, "276\n");
    fflush(_coverage_fout);
    ___coverage_array[276] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[268] == 0) {
      {
      fprintf(_coverage_fout, "268\n");
      fflush(_coverage_fout);
      ___coverage_array[268] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[269] == 0) {
      {
      fprintf(_coverage_fout, "269\n");
      fflush(_coverage_fout);
      ___coverage_array[269] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[270] == 0) {
      {
      fprintf(_coverage_fout, "270\n");
      fflush(_coverage_fout);
      ___coverage_array[270] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[271] == 0) {
      {
      fprintf(_coverage_fout, "271\n");
      fflush(_coverage_fout);
      ___coverage_array[271] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[272] == 0) {
      {
      fprintf(_coverage_fout, "272\n");
      fflush(_coverage_fout);
      ___coverage_array[272] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[273] == 0) {
      {
      fprintf(_coverage_fout, "273\n");
      fflush(_coverage_fout);
      ___coverage_array[273] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[274] == 0) {
      {
      fprintf(_coverage_fout, "274\n");
      fflush(_coverage_fout);
      ___coverage_array[274] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[277] == 0) {
    {
    fprintf(_coverage_fout, "277\n");
    fflush(_coverage_fout);
    ___coverage_array[277] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[285] == 0) {
    {
    fprintf(_coverage_fout, "285\n");
    fflush(_coverage_fout);
    ___coverage_array[285] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[286] == 0) {
    {
    fprintf(_coverage_fout, "286\n");
    fflush(_coverage_fout);
    ___coverage_array[286] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[278] == 0) {
      {
      fprintf(_coverage_fout, "278\n");
      fflush(_coverage_fout);
      ___coverage_array[278] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __overflow(stdout, (int )((unsigned char )__c));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[279] == 0) {
      {
      fprintf(_coverage_fout, "279\n");
      fflush(_coverage_fout);
      ___coverage_array[279] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[280] == 0) {
      {
      fprintf(_coverage_fout, "280\n");
      fflush(_coverage_fout);
      ___coverage_array[280] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = stdout->_IO_write_ptr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[281] == 0) {
      {
      fprintf(_coverage_fout, "281\n");
      fflush(_coverage_fout);
      ___coverage_array[281] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (stdout->_IO_write_ptr) ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[282] == 0) {
      {
      fprintf(_coverage_fout, "282\n");
      fflush(_coverage_fout);
      ___coverage_array[282] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[283] == 0) {
      {
      fprintf(_coverage_fout, "283\n");
      fflush(_coverage_fout);
      ___coverage_array[283] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[284] == 0) {
      {
      fprintf(_coverage_fout, "284\n");
      fflush(_coverage_fout);
      ___coverage_array[284] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[287] == 0) {
    {
    fprintf(_coverage_fout, "287\n");
    fflush(_coverage_fout);
    ___coverage_array[287] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[288] == 0) {
    {
    fprintf(_coverage_fout, "288\n");
    fflush(_coverage_fout);
    ___coverage_array[288] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __getdelim(__lineptr, __n, '\n', __stream);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[289] == 0) {
    {
    fprintf(_coverage_fout, "289\n");
    fflush(_coverage_fout);
    ___coverage_array[289] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[290] == 0) {
    {
    fprintf(_coverage_fout, "290\n");
    fflush(_coverage_fout);
    ___coverage_array[290] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[291] == 0) {
    {
    fprintf(_coverage_fout, "291\n");
    fflush(_coverage_fout);
    ___coverage_array[291] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[294] == 0) {
    {
    fprintf(_coverage_fout, "294\n");
    fflush(_coverage_fout);
    ___coverage_array[294] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = malloc(len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[295] == 0) {
    {
    fprintf(_coverage_fout, "295\n");
    fflush(_coverage_fout);
    ___coverage_array[295] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[296] == 0) {
    {
    fprintf(_coverage_fout, "296\n");
    fflush(_coverage_fout);
    ___coverage_array[296] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[292] == 0) {
      {
      fprintf(_coverage_fout, "292\n");
      fflush(_coverage_fout);
      ___coverage_array[292] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[293] == 0) {
      {
      fprintf(_coverage_fout, "293\n");
      fflush(_coverage_fout);
      ___coverage_array[293] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[297] == 0) {
    {
    fprintf(_coverage_fout, "297\n");
    fflush(_coverage_fout);
    ___coverage_array[297] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[298] == 0) {
    {
    fprintf(_coverage_fout, "298\n");
    fflush(_coverage_fout);
    ___coverage_array[298] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[299] == 0) {
    {
    fprintf(_coverage_fout, "299\n");
    fflush(_coverage_fout);
    ___coverage_array[299] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = _safe_malloc(nmemb, len, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[300] == 0) {
    {
    fprintf(_coverage_fout, "300\n");
    fflush(_coverage_fout);
    ___coverage_array[300] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (void *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[301] == 0) {
    {
    fprintf(_coverage_fout, "301\n");
    fflush(_coverage_fout);
    ___coverage_array[301] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset(tmp, 0, nmemb * len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[302] == 0) {
    {
    fprintf(_coverage_fout, "302\n");
    fflush(_coverage_fout);
    ___coverage_array[302] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[305] == 0) {
    {
    fprintf(_coverage_fout, "305\n");
    fflush(_coverage_fout);
    ___coverage_array[305] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = realloc(p, len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[306] == 0) {
    {
    fprintf(_coverage_fout, "306\n");
    fflush(_coverage_fout);
    ___coverage_array[306] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (p) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[303] == 0) {
      {
      fprintf(_coverage_fout, "303\n");
      fflush(_coverage_fout);
      ___coverage_array[303] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[304] == 0) {
      {
      fprintf(_coverage_fout, "304\n");
      fflush(_coverage_fout);
      ___coverage_array[304] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[307] == 0) {
    {
    fprintf(_coverage_fout, "307\n");
    fflush(_coverage_fout);
    ___coverage_array[307] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[308] == 0) {
    {
    fprintf(_coverage_fout, "308\n");
    fflush(_coverage_fout);
    ___coverage_array[308] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[357] == 0) {
    {
    fprintf(_coverage_fout, "357\n");
    fflush(_coverage_fout);
    ___coverage_array[357] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = (ulong )5381;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[358] == 0) {
    {
    fprintf(_coverage_fout, "358\n");
    fflush(_coverage_fout);
    ___coverage_array[358] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[310] == 0) {
      {
      fprintf(_coverage_fout, "310\n");
      fflush(_coverage_fout);
      ___coverage_array[310] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (nKeyLength >= 8U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[309] == 0) {
        {
        fprintf(_coverage_fout, "309\n");
        fflush(_coverage_fout);
        ___coverage_array[309] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[311] == 0) {
      {
      fprintf(_coverage_fout, "311\n");
      fflush(_coverage_fout);
      ___coverage_array[311] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[312] == 0) {
      {
      fprintf(_coverage_fout, "312\n");
      fflush(_coverage_fout);
      ___coverage_array[312] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[313] == 0) {
      {
      fprintf(_coverage_fout, "313\n");
      fflush(_coverage_fout);
      ___coverage_array[313] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[314] == 0) {
      {
      fprintf(_coverage_fout, "314\n");
      fflush(_coverage_fout);
      ___coverage_array[314] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[315] == 0) {
      {
      fprintf(_coverage_fout, "315\n");
      fflush(_coverage_fout);
      ___coverage_array[315] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[316] == 0) {
      {
      fprintf(_coverage_fout, "316\n");
      fflush(_coverage_fout);
      ___coverage_array[316] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[317] == 0) {
      {
      fprintf(_coverage_fout, "317\n");
      fflush(_coverage_fout);
      ___coverage_array[317] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[318] == 0) {
      {
      fprintf(_coverage_fout, "318\n");
      fflush(_coverage_fout);
      ___coverage_array[318] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[319] == 0) {
      {
      fprintf(_coverage_fout, "319\n");
      fflush(_coverage_fout);
      ___coverage_array[319] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[320] == 0) {
      {
      fprintf(_coverage_fout, "320\n");
      fflush(_coverage_fout);
      ___coverage_array[320] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[321] == 0) {
      {
      fprintf(_coverage_fout, "321\n");
      fflush(_coverage_fout);
      ___coverage_array[321] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[322] == 0) {
      {
      fprintf(_coverage_fout, "322\n");
      fflush(_coverage_fout);
      ___coverage_array[322] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[323] == 0) {
      {
      fprintf(_coverage_fout, "323\n");
      fflush(_coverage_fout);
      ___coverage_array[323] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[324] == 0) {
      {
      fprintf(_coverage_fout, "324\n");
      fflush(_coverage_fout);
      ___coverage_array[324] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[325] == 0) {
      {
      fprintf(_coverage_fout, "325\n");
      fflush(_coverage_fout);
      ___coverage_array[325] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[326] == 0) {
      {
      fprintf(_coverage_fout, "326\n");
      fflush(_coverage_fout);
      ___coverage_array[326] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[327] == 0) {
      {
      fprintf(_coverage_fout, "327\n");
      fflush(_coverage_fout);
      ___coverage_array[327] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[328] == 0) {
      {
      fprintf(_coverage_fout, "328\n");
      fflush(_coverage_fout);
      ___coverage_array[328] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___4;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[329] == 0) {
      {
      fprintf(_coverage_fout, "329\n");
      fflush(_coverage_fout);
      ___coverage_array[329] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[330] == 0) {
      {
      fprintf(_coverage_fout, "330\n");
      fflush(_coverage_fout);
      ___coverage_array[330] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[331] == 0) {
      {
      fprintf(_coverage_fout, "331\n");
      fflush(_coverage_fout);
      ___coverage_array[331] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___5;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[332] == 0) {
      {
      fprintf(_coverage_fout, "332\n");
      fflush(_coverage_fout);
      ___coverage_array[332] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = arKey;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[333] == 0) {
      {
      fprintf(_coverage_fout, "333\n");
      fflush(_coverage_fout);
      ___coverage_array[333] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    arKey ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[334] == 0) {
      {
      fprintf(_coverage_fout, "334\n");
      fflush(_coverage_fout);
      ___coverage_array[334] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    hash = ((hash << 5) + hash) + (ulong )*tmp___6;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[335] == 0) {
      {
      fprintf(_coverage_fout, "335\n");
      fflush(_coverage_fout);
      ___coverage_array[335] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    nKeyLength -= 8U;
  }
  switch ((int )nKeyLength) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[336] == 0) {
    {
    fprintf(_coverage_fout, "336\n");
    fflush(_coverage_fout);
    ___coverage_array[336] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 7: 
  tmp___7 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[337] == 0) {
    {
    fprintf(_coverage_fout, "337\n");
    fflush(_coverage_fout);
    ___coverage_array[337] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[338] == 0) {
    {
    fprintf(_coverage_fout, "338\n");
    fflush(_coverage_fout);
    ___coverage_array[338] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___7;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[339] == 0) {
    {
    fprintf(_coverage_fout, "339\n");
    fflush(_coverage_fout);
    ___coverage_array[339] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 6: 
  tmp___8 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[340] == 0) {
    {
    fprintf(_coverage_fout, "340\n");
    fflush(_coverage_fout);
    ___coverage_array[340] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[341] == 0) {
    {
    fprintf(_coverage_fout, "341\n");
    fflush(_coverage_fout);
    ___coverage_array[341] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___8;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[342] == 0) {
    {
    fprintf(_coverage_fout, "342\n");
    fflush(_coverage_fout);
    ___coverage_array[342] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 5: 
  tmp___9 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[343] == 0) {
    {
    fprintf(_coverage_fout, "343\n");
    fflush(_coverage_fout);
    ___coverage_array[343] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[344] == 0) {
    {
    fprintf(_coverage_fout, "344\n");
    fflush(_coverage_fout);
    ___coverage_array[344] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___9;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[345] == 0) {
    {
    fprintf(_coverage_fout, "345\n");
    fflush(_coverage_fout);
    ___coverage_array[345] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 4: 
  tmp___10 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[346] == 0) {
    {
    fprintf(_coverage_fout, "346\n");
    fflush(_coverage_fout);
    ___coverage_array[346] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[347] == 0) {
    {
    fprintf(_coverage_fout, "347\n");
    fflush(_coverage_fout);
    ___coverage_array[347] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___10;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[348] == 0) {
    {
    fprintf(_coverage_fout, "348\n");
    fflush(_coverage_fout);
    ___coverage_array[348] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  tmp___11 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[349] == 0) {
    {
    fprintf(_coverage_fout, "349\n");
    fflush(_coverage_fout);
    ___coverage_array[349] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[350] == 0) {
    {
    fprintf(_coverage_fout, "350\n");
    fflush(_coverage_fout);
    ___coverage_array[350] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___11;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[351] == 0) {
    {
    fprintf(_coverage_fout, "351\n");
    fflush(_coverage_fout);
    ___coverage_array[351] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  tmp___12 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[352] == 0) {
    {
    fprintf(_coverage_fout, "352\n");
    fflush(_coverage_fout);
    ___coverage_array[352] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[353] == 0) {
    {
    fprintf(_coverage_fout, "353\n");
    fflush(_coverage_fout);
    ___coverage_array[353] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hash = ((hash << 5) + hash) + (ulong )*tmp___12;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[354] == 0) {
    {
    fprintf(_coverage_fout, "354\n");
    fflush(_coverage_fout);
    ___coverage_array[354] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___13 = arKey;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[355] == 0) {
    {
    fprintf(_coverage_fout, "355\n");
    fflush(_coverage_fout);
    ___coverage_array[355] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arKey ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[356] == 0) {
    {
    fprintf(_coverage_fout, "356\n");
    fflush(_coverage_fout);
    ___coverage_array[356] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[359] == 0) {
    {
    fprintf(_coverage_fout, "359\n");
    fflush(_coverage_fout);
    ___coverage_array[359] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[396] == 0) {
    {
    fprintf(_coverage_fout, "396\n");
    fflush(_coverage_fout);
    ___coverage_array[396] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[395] == 0) {
      {
      fprintf(_coverage_fout, "395\n");
      fflush(_coverage_fout);
      ___coverage_array[395] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[392] == 0) {
        {
        fprintf(_coverage_fout, "392\n");
        fflush(_coverage_fout);
        ___coverage_array[392] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[393] == 0) {
        {
        fprintf(_coverage_fout, "393\n");
        fflush(_coverage_fout);
        ___coverage_array[393] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[360] == 0) {
          {
          fprintf(_coverage_fout, "360\n");
          fflush(_coverage_fout);
          ___coverage_array[360] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[361] == 0) {
          {
          fprintf(_coverage_fout, "361\n");
          fflush(_coverage_fout);
          ___coverage_array[361] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[394] == 0) {
        {
        fprintf(_coverage_fout, "394\n");
        fflush(_coverage_fout);
        ___coverage_array[394] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[390] == 0) {
          {
          fprintf(_coverage_fout, "390\n");
          fflush(_coverage_fout);
          ___coverage_array[390] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[384] == 0) {
            {
            fprintf(_coverage_fout, "384\n");
            fflush(_coverage_fout);
            ___coverage_array[384] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[385] == 0) {
            {
            fprintf(_coverage_fout, "385\n");
            fflush(_coverage_fout);
            ___coverage_array[385] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[368] == 0) {
              {
              fprintf(_coverage_fout, "368\n");
              fflush(_coverage_fout);
              ___coverage_array[368] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[362] == 0) {
                {
                fprintf(_coverage_fout, "362\n");
                fflush(_coverage_fout);
                ___coverage_array[362] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[367] == 0) {
                {
                fprintf(_coverage_fout, "367\n");
                fflush(_coverage_fout);
                ___coverage_array[367] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[366] == 0) {
                  {
                  fprintf(_coverage_fout, "366\n");
                  fflush(_coverage_fout);
                  ___coverage_array[366] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[364] == 0) {
                    {
                    fprintf(_coverage_fout, "364\n");
                    fflush(_coverage_fout);
                    ___coverage_array[364] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[363] == 0) {
                      {
                      fprintf(_coverage_fout, "363\n");
                      fflush(_coverage_fout);
                      ___coverage_array[363] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[365] == 0) {
                    {
                    fprintf(_coverage_fout, "365\n");
                    fflush(_coverage_fout);
                    ___coverage_array[365] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[386] == 0) {
            {
            fprintf(_coverage_fout, "386\n");
            fflush(_coverage_fout);
            ___coverage_array[386] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[387] == 0) {
            {
            fprintf(_coverage_fout, "387\n");
            fflush(_coverage_fout);
            ___coverage_array[387] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[372] == 0) {
              {
              fprintf(_coverage_fout, "372\n");
              fflush(_coverage_fout);
              ___coverage_array[372] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[373] == 0) {
              {
              fprintf(_coverage_fout, "373\n");
              fflush(_coverage_fout);
              ___coverage_array[373] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[371] == 0) {
                {
                fprintf(_coverage_fout, "371\n");
                fflush(_coverage_fout);
                ___coverage_array[371] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[370] == 0) {
                  {
                  fprintf(_coverage_fout, "370\n");
                  fflush(_coverage_fout);
                  ___coverage_array[370] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[369] == 0) {
                    {
                    fprintf(_coverage_fout, "369\n");
                    fflush(_coverage_fout);
                    ___coverage_array[369] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[374] == 0) {
              {
              fprintf(_coverage_fout, "374\n");
              fflush(_coverage_fout);
              ___coverage_array[374] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[388] == 0) {
            {
            fprintf(_coverage_fout, "388\n");
            fflush(_coverage_fout);
            ___coverage_array[388] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[380] == 0) {
              {
              fprintf(_coverage_fout, "380\n");
              fflush(_coverage_fout);
              ___coverage_array[380] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[376] == 0) {
                {
                fprintf(_coverage_fout, "376\n");
                fflush(_coverage_fout);
                ___coverage_array[376] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[375] == 0) {
                  {
                  fprintf(_coverage_fout, "375\n");
                  fflush(_coverage_fout);
                  ___coverage_array[375] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[377] == 0) {
                {
                fprintf(_coverage_fout, "377\n");
                fflush(_coverage_fout);
                ___coverage_array[377] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[379] == 0) {
                {
                fprintf(_coverage_fout, "379\n");
                fflush(_coverage_fout);
                ___coverage_array[379] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[378] == 0) {
                  {
                  fprintf(_coverage_fout, "378\n");
                  fflush(_coverage_fout);
                  ___coverage_array[378] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[381] == 0) {
              {
              fprintf(_coverage_fout, "381\n");
              fflush(_coverage_fout);
              ___coverage_array[381] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[382] == 0) {
              {
              fprintf(_coverage_fout, "382\n");
              fflush(_coverage_fout);
              ___coverage_array[382] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[383] == 0) {
              {
              fprintf(_coverage_fout, "383\n");
              fflush(_coverage_fout);
              ___coverage_array[383] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[389] == 0) {
            {
            fprintf(_coverage_fout, "389\n");
            fflush(_coverage_fout);
            ___coverage_array[389] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[391] == 0) {
          {
          fprintf(_coverage_fout, "391\n");
          fflush(_coverage_fout);
          ___coverage_array[391] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[397] == 0) {
    {
    fprintf(_coverage_fout, "397\n");
    fflush(_coverage_fout);
    ___coverage_array[397] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[398] == 0) {
    {
    fprintf(_coverage_fout, "398\n");
    fflush(_coverage_fout);
    ___coverage_array[398] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[435] == 0) {
    {
    fprintf(_coverage_fout, "435\n");
    fflush(_coverage_fout);
    ___coverage_array[435] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[434] == 0) {
      {
      fprintf(_coverage_fout, "434\n");
      fflush(_coverage_fout);
      ___coverage_array[434] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[431] == 0) {
        {
        fprintf(_coverage_fout, "431\n");
        fflush(_coverage_fout);
        ___coverage_array[431] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[432] == 0) {
        {
        fprintf(_coverage_fout, "432\n");
        fflush(_coverage_fout);
        ___coverage_array[432] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[399] == 0) {
          {
          fprintf(_coverage_fout, "399\n");
          fflush(_coverage_fout);
          ___coverage_array[399] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[400] == 0) {
          {
          fprintf(_coverage_fout, "400\n");
          fflush(_coverage_fout);
          ___coverage_array[400] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[433] == 0) {
        {
        fprintf(_coverage_fout, "433\n");
        fflush(_coverage_fout);
        ___coverage_array[433] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[429] == 0) {
          {
          fprintf(_coverage_fout, "429\n");
          fflush(_coverage_fout);
          ___coverage_array[429] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[423] == 0) {
            {
            fprintf(_coverage_fout, "423\n");
            fflush(_coverage_fout);
            ___coverage_array[423] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[424] == 0) {
            {
            fprintf(_coverage_fout, "424\n");
            fflush(_coverage_fout);
            ___coverage_array[424] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[407] == 0) {
              {
              fprintf(_coverage_fout, "407\n");
              fflush(_coverage_fout);
              ___coverage_array[407] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[401] == 0) {
                {
                fprintf(_coverage_fout, "401\n");
                fflush(_coverage_fout);
                ___coverage_array[401] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[406] == 0) {
                {
                fprintf(_coverage_fout, "406\n");
                fflush(_coverage_fout);
                ___coverage_array[406] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[405] == 0) {
                  {
                  fprintf(_coverage_fout, "405\n");
                  fflush(_coverage_fout);
                  ___coverage_array[405] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[403] == 0) {
                    {
                    fprintf(_coverage_fout, "403\n");
                    fflush(_coverage_fout);
                    ___coverage_array[403] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[402] == 0) {
                      {
                      fprintf(_coverage_fout, "402\n");
                      fflush(_coverage_fout);
                      ___coverage_array[402] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[404] == 0) {
                    {
                    fprintf(_coverage_fout, "404\n");
                    fflush(_coverage_fout);
                    ___coverage_array[404] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[425] == 0) {
            {
            fprintf(_coverage_fout, "425\n");
            fflush(_coverage_fout);
            ___coverage_array[425] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[426] == 0) {
            {
            fprintf(_coverage_fout, "426\n");
            fflush(_coverage_fout);
            ___coverage_array[426] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[411] == 0) {
              {
              fprintf(_coverage_fout, "411\n");
              fflush(_coverage_fout);
              ___coverage_array[411] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[412] == 0) {
              {
              fprintf(_coverage_fout, "412\n");
              fflush(_coverage_fout);
              ___coverage_array[412] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[410] == 0) {
                {
                fprintf(_coverage_fout, "410\n");
                fflush(_coverage_fout);
                ___coverage_array[410] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[409] == 0) {
                  {
                  fprintf(_coverage_fout, "409\n");
                  fflush(_coverage_fout);
                  ___coverage_array[409] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[408] == 0) {
                    {
                    fprintf(_coverage_fout, "408\n");
                    fflush(_coverage_fout);
                    ___coverage_array[408] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[413] == 0) {
              {
              fprintf(_coverage_fout, "413\n");
              fflush(_coverage_fout);
              ___coverage_array[413] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[427] == 0) {
            {
            fprintf(_coverage_fout, "427\n");
            fflush(_coverage_fout);
            ___coverage_array[427] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[419] == 0) {
              {
              fprintf(_coverage_fout, "419\n");
              fflush(_coverage_fout);
              ___coverage_array[419] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[415] == 0) {
                {
                fprintf(_coverage_fout, "415\n");
                fflush(_coverage_fout);
                ___coverage_array[415] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[414] == 0) {
                  {
                  fprintf(_coverage_fout, "414\n");
                  fflush(_coverage_fout);
                  ___coverage_array[414] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[416] == 0) {
                {
                fprintf(_coverage_fout, "416\n");
                fflush(_coverage_fout);
                ___coverage_array[416] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[418] == 0) {
                {
                fprintf(_coverage_fout, "418\n");
                fflush(_coverage_fout);
                ___coverage_array[418] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[417] == 0) {
                  {
                  fprintf(_coverage_fout, "417\n");
                  fflush(_coverage_fout);
                  ___coverage_array[417] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[420] == 0) {
              {
              fprintf(_coverage_fout, "420\n");
              fflush(_coverage_fout);
              ___coverage_array[420] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[421] == 0) {
              {
              fprintf(_coverage_fout, "421\n");
              fflush(_coverage_fout);
              ___coverage_array[421] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[422] == 0) {
              {
              fprintf(_coverage_fout, "422\n");
              fflush(_coverage_fout);
              ___coverage_array[422] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[428] == 0) {
            {
            fprintf(_coverage_fout, "428\n");
            fflush(_coverage_fout);
            ___coverage_array[428] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[430] == 0) {
          {
          fprintf(_coverage_fout, "430\n");
          fflush(_coverage_fout);
          ___coverage_array[430] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[436] == 0) {
    {
    fprintf(_coverage_fout, "436\n");
    fflush(_coverage_fout);
    ___coverage_array[436] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[437] == 0) {
    {
    fprintf(_coverage_fout, "437\n");
    fflush(_coverage_fout);
    ___coverage_array[437] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[474] == 0) {
    {
    fprintf(_coverage_fout, "474\n");
    fflush(_coverage_fout);
    ___coverage_array[474] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[473] == 0) {
      {
      fprintf(_coverage_fout, "473\n");
      fflush(_coverage_fout);
      ___coverage_array[473] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[470] == 0) {
        {
        fprintf(_coverage_fout, "470\n");
        fflush(_coverage_fout);
        ___coverage_array[470] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[471] == 0) {
        {
        fprintf(_coverage_fout, "471\n");
        fflush(_coverage_fout);
        ___coverage_array[471] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[438] == 0) {
          {
          fprintf(_coverage_fout, "438\n");
          fflush(_coverage_fout);
          ___coverage_array[438] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[439] == 0) {
          {
          fprintf(_coverage_fout, "439\n");
          fflush(_coverage_fout);
          ___coverage_array[439] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[472] == 0) {
        {
        fprintf(_coverage_fout, "472\n");
        fflush(_coverage_fout);
        ___coverage_array[472] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[468] == 0) {
          {
          fprintf(_coverage_fout, "468\n");
          fflush(_coverage_fout);
          ___coverage_array[468] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[462] == 0) {
            {
            fprintf(_coverage_fout, "462\n");
            fflush(_coverage_fout);
            ___coverage_array[462] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[463] == 0) {
            {
            fprintf(_coverage_fout, "463\n");
            fflush(_coverage_fout);
            ___coverage_array[463] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[446] == 0) {
              {
              fprintf(_coverage_fout, "446\n");
              fflush(_coverage_fout);
              ___coverage_array[446] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[440] == 0) {
                {
                fprintf(_coverage_fout, "440\n");
                fflush(_coverage_fout);
                ___coverage_array[440] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[445] == 0) {
                {
                fprintf(_coverage_fout, "445\n");
                fflush(_coverage_fout);
                ___coverage_array[445] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[444] == 0) {
                  {
                  fprintf(_coverage_fout, "444\n");
                  fflush(_coverage_fout);
                  ___coverage_array[444] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[442] == 0) {
                    {
                    fprintf(_coverage_fout, "442\n");
                    fflush(_coverage_fout);
                    ___coverage_array[442] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[441] == 0) {
                      {
                      fprintf(_coverage_fout, "441\n");
                      fflush(_coverage_fout);
                      ___coverage_array[441] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[443] == 0) {
                    {
                    fprintf(_coverage_fout, "443\n");
                    fflush(_coverage_fout);
                    ___coverage_array[443] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[464] == 0) {
            {
            fprintf(_coverage_fout, "464\n");
            fflush(_coverage_fout);
            ___coverage_array[464] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[465] == 0) {
            {
            fprintf(_coverage_fout, "465\n");
            fflush(_coverage_fout);
            ___coverage_array[465] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[450] == 0) {
              {
              fprintf(_coverage_fout, "450\n");
              fflush(_coverage_fout);
              ___coverage_array[450] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[451] == 0) {
              {
              fprintf(_coverage_fout, "451\n");
              fflush(_coverage_fout);
              ___coverage_array[451] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[449] == 0) {
                {
                fprintf(_coverage_fout, "449\n");
                fflush(_coverage_fout);
                ___coverage_array[449] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[448] == 0) {
                  {
                  fprintf(_coverage_fout, "448\n");
                  fflush(_coverage_fout);
                  ___coverage_array[448] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[447] == 0) {
                    {
                    fprintf(_coverage_fout, "447\n");
                    fflush(_coverage_fout);
                    ___coverage_array[447] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[452] == 0) {
              {
              fprintf(_coverage_fout, "452\n");
              fflush(_coverage_fout);
              ___coverage_array[452] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[466] == 0) {
            {
            fprintf(_coverage_fout, "466\n");
            fflush(_coverage_fout);
            ___coverage_array[466] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[458] == 0) {
              {
              fprintf(_coverage_fout, "458\n");
              fflush(_coverage_fout);
              ___coverage_array[458] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[454] == 0) {
                {
                fprintf(_coverage_fout, "454\n");
                fflush(_coverage_fout);
                ___coverage_array[454] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[453] == 0) {
                  {
                  fprintf(_coverage_fout, "453\n");
                  fflush(_coverage_fout);
                  ___coverage_array[453] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[455] == 0) {
                {
                fprintf(_coverage_fout, "455\n");
                fflush(_coverage_fout);
                ___coverage_array[455] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[457] == 0) {
                {
                fprintf(_coverage_fout, "457\n");
                fflush(_coverage_fout);
                ___coverage_array[457] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[456] == 0) {
                  {
                  fprintf(_coverage_fout, "456\n");
                  fflush(_coverage_fout);
                  ___coverage_array[456] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[459] == 0) {
              {
              fprintf(_coverage_fout, "459\n");
              fflush(_coverage_fout);
              ___coverage_array[459] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[460] == 0) {
              {
              fprintf(_coverage_fout, "460\n");
              fflush(_coverage_fout);
              ___coverage_array[460] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[461] == 0) {
              {
              fprintf(_coverage_fout, "461\n");
              fflush(_coverage_fout);
              ___coverage_array[461] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[467] == 0) {
            {
            fprintf(_coverage_fout, "467\n");
            fflush(_coverage_fout);
            ___coverage_array[467] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[469] == 0) {
          {
          fprintf(_coverage_fout, "469\n");
          fflush(_coverage_fout);
          ___coverage_array[469] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[475] == 0) {
    {
    fprintf(_coverage_fout, "475\n");
    fflush(_coverage_fout);
    ___coverage_array[475] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[476] == 0) {
    {
    fprintf(_coverage_fout, "476\n");
    fflush(_coverage_fout);
    ___coverage_array[476] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[513] == 0) {
    {
    fprintf(_coverage_fout, "513\n");
    fflush(_coverage_fout);
    ___coverage_array[513] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[512] == 0) {
      {
      fprintf(_coverage_fout, "512\n");
      fflush(_coverage_fout);
      ___coverage_array[512] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[509] == 0) {
        {
        fprintf(_coverage_fout, "509\n");
        fflush(_coverage_fout);
        ___coverage_array[509] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[510] == 0) {
        {
        fprintf(_coverage_fout, "510\n");
        fflush(_coverage_fout);
        ___coverage_array[510] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[477] == 0) {
          {
          fprintf(_coverage_fout, "477\n");
          fflush(_coverage_fout);
          ___coverage_array[477] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[478] == 0) {
          {
          fprintf(_coverage_fout, "478\n");
          fflush(_coverage_fout);
          ___coverage_array[478] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[511] == 0) {
        {
        fprintf(_coverage_fout, "511\n");
        fflush(_coverage_fout);
        ___coverage_array[511] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[507] == 0) {
          {
          fprintf(_coverage_fout, "507\n");
          fflush(_coverage_fout);
          ___coverage_array[507] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[501] == 0) {
            {
            fprintf(_coverage_fout, "501\n");
            fflush(_coverage_fout);
            ___coverage_array[501] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[502] == 0) {
            {
            fprintf(_coverage_fout, "502\n");
            fflush(_coverage_fout);
            ___coverage_array[502] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[485] == 0) {
              {
              fprintf(_coverage_fout, "485\n");
              fflush(_coverage_fout);
              ___coverage_array[485] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[479] == 0) {
                {
                fprintf(_coverage_fout, "479\n");
                fflush(_coverage_fout);
                ___coverage_array[479] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[484] == 0) {
                {
                fprintf(_coverage_fout, "484\n");
                fflush(_coverage_fout);
                ___coverage_array[484] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[483] == 0) {
                  {
                  fprintf(_coverage_fout, "483\n");
                  fflush(_coverage_fout);
                  ___coverage_array[483] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[481] == 0) {
                    {
                    fprintf(_coverage_fout, "481\n");
                    fflush(_coverage_fout);
                    ___coverage_array[481] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[480] == 0) {
                      {
                      fprintf(_coverage_fout, "480\n");
                      fflush(_coverage_fout);
                      ___coverage_array[480] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[482] == 0) {
                    {
                    fprintf(_coverage_fout, "482\n");
                    fflush(_coverage_fout);
                    ___coverage_array[482] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[503] == 0) {
            {
            fprintf(_coverage_fout, "503\n");
            fflush(_coverage_fout);
            ___coverage_array[503] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[504] == 0) {
            {
            fprintf(_coverage_fout, "504\n");
            fflush(_coverage_fout);
            ___coverage_array[504] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[489] == 0) {
              {
              fprintf(_coverage_fout, "489\n");
              fflush(_coverage_fout);
              ___coverage_array[489] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[490] == 0) {
              {
              fprintf(_coverage_fout, "490\n");
              fflush(_coverage_fout);
              ___coverage_array[490] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[488] == 0) {
                {
                fprintf(_coverage_fout, "488\n");
                fflush(_coverage_fout);
                ___coverage_array[488] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[487] == 0) {
                  {
                  fprintf(_coverage_fout, "487\n");
                  fflush(_coverage_fout);
                  ___coverage_array[487] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[486] == 0) {
                    {
                    fprintf(_coverage_fout, "486\n");
                    fflush(_coverage_fout);
                    ___coverage_array[486] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[491] == 0) {
              {
              fprintf(_coverage_fout, "491\n");
              fflush(_coverage_fout);
              ___coverage_array[491] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[505] == 0) {
            {
            fprintf(_coverage_fout, "505\n");
            fflush(_coverage_fout);
            ___coverage_array[505] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[497] == 0) {
              {
              fprintf(_coverage_fout, "497\n");
              fflush(_coverage_fout);
              ___coverage_array[497] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[493] == 0) {
                {
                fprintf(_coverage_fout, "493\n");
                fflush(_coverage_fout);
                ___coverage_array[493] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[492] == 0) {
                  {
                  fprintf(_coverage_fout, "492\n");
                  fflush(_coverage_fout);
                  ___coverage_array[492] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[494] == 0) {
                {
                fprintf(_coverage_fout, "494\n");
                fflush(_coverage_fout);
                ___coverage_array[494] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[496] == 0) {
                {
                fprintf(_coverage_fout, "496\n");
                fflush(_coverage_fout);
                ___coverage_array[496] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[495] == 0) {
                  {
                  fprintf(_coverage_fout, "495\n");
                  fflush(_coverage_fout);
                  ___coverage_array[495] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[498] == 0) {
              {
              fprintf(_coverage_fout, "498\n");
              fflush(_coverage_fout);
              ___coverage_array[498] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[499] == 0) {
              {
              fprintf(_coverage_fout, "499\n");
              fflush(_coverage_fout);
              ___coverage_array[499] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[500] == 0) {
              {
              fprintf(_coverage_fout, "500\n");
              fflush(_coverage_fout);
              ___coverage_array[500] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[506] == 0) {
            {
            fprintf(_coverage_fout, "506\n");
            fflush(_coverage_fout);
            ___coverage_array[506] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[508] == 0) {
          {
          fprintf(_coverage_fout, "508\n");
          fflush(_coverage_fout);
          ___coverage_array[508] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[514] == 0) {
    {
    fprintf(_coverage_fout, "514\n");
    fflush(_coverage_fout);
    ___coverage_array[514] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[515] == 0) {
    {
    fprintf(_coverage_fout, "515\n");
    fflush(_coverage_fout);
    ___coverage_array[515] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[552] == 0) {
    {
    fprintf(_coverage_fout, "552\n");
    fflush(_coverage_fout);
    ___coverage_array[552] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[551] == 0) {
      {
      fprintf(_coverage_fout, "551\n");
      fflush(_coverage_fout);
      ___coverage_array[551] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[548] == 0) {
        {
        fprintf(_coverage_fout, "548\n");
        fflush(_coverage_fout);
        ___coverage_array[548] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = arKey;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[549] == 0) {
        {
        fprintf(_coverage_fout, "549\n");
        fflush(_coverage_fout);
        ___coverage_array[549] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp == 45) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[516] == 0) {
          {
          fprintf(_coverage_fout, "516\n");
          fflush(_coverage_fout);
          ___coverage_array[516] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp ++;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[517] == 0) {
          {
          fprintf(_coverage_fout, "517\n");
          fflush(_coverage_fout);
          ___coverage_array[517] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[550] == 0) {
        {
        fprintf(_coverage_fout, "550\n");
        fflush(_coverage_fout);
        ___coverage_array[550] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*tmp >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[546] == 0) {
          {
          fprintf(_coverage_fout, "546\n");
          fflush(_coverage_fout);
          ___coverage_array[546] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*tmp <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[540] == 0) {
            {
            fprintf(_coverage_fout, "540\n");
            fflush(_coverage_fout);
            ___coverage_array[540] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          end = (arKey + nKeyLength) - 1;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[541] == 0) {
            {
            fprintf(_coverage_fout, "541\n");
            fflush(_coverage_fout);
            ___coverage_array[541] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*end != 0) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[524] == 0) {
              {
              fprintf(_coverage_fout, "524\n");
              fflush(_coverage_fout);
              ___coverage_array[524] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*tmp == 48) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[518] == 0) {
                {
                fprintf(_coverage_fout, "518\n");
                fflush(_coverage_fout);
                ___coverage_array[518] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[523] == 0) {
                {
                fprintf(_coverage_fout, "523\n");
                fflush(_coverage_fout);
                ___coverage_array[523] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[522] == 0) {
                  {
                  fprintf(_coverage_fout, "522\n");
                  fflush(_coverage_fout);
                  ___coverage_array[522] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if (end - tmp == 10) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[520] == 0) {
                    {
                    fprintf(_coverage_fout, "520\n");
                    fflush(_coverage_fout);
                    ___coverage_array[520] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[519] == 0) {
                      {
                      fprintf(_coverage_fout, "519\n");
                      fflush(_coverage_fout);
                      ___coverage_array[519] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[521] == 0) {
                    {
                    fprintf(_coverage_fout, "521\n");
                    fflush(_coverage_fout);
                    ___coverage_array[521] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                }
              }
            }
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[542] == 0) {
            {
            fprintf(_coverage_fout, "542\n");
            fflush(_coverage_fout);
            ___coverage_array[542] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[543] == 0) {
            {
            fprintf(_coverage_fout, "543\n");
            fflush(_coverage_fout);
            ___coverage_array[543] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[528] == 0) {
              {
              fprintf(_coverage_fout, "528\n");
              fflush(_coverage_fout);
              ___coverage_array[528] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp ++;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[529] == 0) {
              {
              fprintf(_coverage_fout, "529\n");
              fflush(_coverage_fout);
              ___coverage_array[529] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((unsigned int )tmp != (unsigned int )end) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[527] == 0) {
                {
                fprintf(_coverage_fout, "527\n");
                fflush(_coverage_fout);
                ___coverage_array[527] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*tmp >= 48) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[526] == 0) {
                  {
                  fprintf(_coverage_fout, "526\n");
                  fflush(_coverage_fout);
                  ___coverage_array[526] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp <= 57) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[525] == 0) {
                    {
                    fprintf(_coverage_fout, "525\n");
                    fflush(_coverage_fout);
                    ___coverage_array[525] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[530] == 0) {
              {
              fprintf(_coverage_fout, "530\n");
              fflush(_coverage_fout);
              ___coverage_array[530] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[544] == 0) {
            {
            fprintf(_coverage_fout, "544\n");
            fflush(_coverage_fout);
            ___coverage_array[544] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[536] == 0) {
              {
              fprintf(_coverage_fout, "536\n");
              fflush(_coverage_fout);
              ___coverage_array[536] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*arKey == 45) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[532] == 0) {
                {
                fprintf(_coverage_fout, "532\n");
                fflush(_coverage_fout);
                ___coverage_array[532] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[531] == 0) {
                  {
                  fprintf(_coverage_fout, "531\n");
                  fflush(_coverage_fout);
                  ___coverage_array[531] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[533] == 0) {
                {
                fprintf(_coverage_fout, "533\n");
                fflush(_coverage_fout);
                ___coverage_array[533] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[535] == 0) {
                {
                fprintf(_coverage_fout, "535\n");
                fflush(_coverage_fout);
                ___coverage_array[535] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (idx > 2147483647UL) {
                break;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[534] == 0) {
                  {
                  fprintf(_coverage_fout, "534\n");
                  fflush(_coverage_fout);
                  ___coverage_array[534] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[537] == 0) {
              {
              fprintf(_coverage_fout, "537\n");
              fflush(_coverage_fout);
              ___coverage_array[537] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[538] == 0) {
              {
              fprintf(_coverage_fout, "538\n");
              fflush(_coverage_fout);
              ___coverage_array[538] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return ((int )tmp___0);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[539] == 0) {
              {
              fprintf(_coverage_fout, "539\n");
              fflush(_coverage_fout);
              ___coverage_array[539] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[545] == 0) {
            {
            fprintf(_coverage_fout, "545\n");
            fflush(_coverage_fout);
            ___coverage_array[545] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[547] == 0) {
          {
          fprintf(_coverage_fout, "547\n");
          fflush(_coverage_fout);
          ___coverage_array[547] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[553] == 0) {
    {
    fprintf(_coverage_fout, "553\n");
    fflush(_coverage_fout);
    ___coverage_array[553] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[554] == 0) {
    {
    fprintf(_coverage_fout, "554\n");
    fflush(_coverage_fout);
    ___coverage_array[554] = 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 
                                                               , ...) ;
extern zend_object_handlers __attribute__((__visibility__("default")))  std_object_handlers ;
extern union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_static_method(zend_class_entry *ce ,
                                                                                                    char *function_name_strval ,
                                                                                                    int function_name_strlen ,
                                                                                                    struct _zend_literal  const  *key ) ;
extern zval __attribute__((__visibility__("default")))  **zend_std_get_static_property(zend_class_entry *ce ,
                                                                                       char *property_name ,
                                                                                       int property_name_len ,
                                                                                       zend_bool silent ,
                                                                                       struct _zend_literal  const  *key ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_std_unset_static_property(zend_class_entry *ce ,
                                                                                            char *property_name ,
                                                                                            int property_name_len ,
                                                                                            struct _zend_literal  const  *key ) ;
extern union _zend_function  __attribute__((__visibility__("default"))) *zend_std_get_constructor(zval *object ) ;
extern struct _zend_property_info  __attribute__((__visibility__("default"))) *zend_get_property_info(zend_class_entry *ce ,
                                                                                                      zval *member ,
                                                                                                      int silent ) ;
extern HashTable __attribute__((__visibility__("default")))  *zend_std_get_properties(zval *object ) ;
extern HashTable __attribute__((__visibility__("default")))  *zend_std_get_debug_info(zval *object ,
                                                                                      int *is_temp ) ;
extern int __attribute__((__visibility__("default")))  zend_std_cast_object_tostring(zval *readobj ,
                                                                                     zval *writeobj ,
                                                                                     int type ) ;
extern void __attribute__((__visibility__("default")))  zend_std_write_property(zval *object ,
                                                                                zval *member ,
                                                                                zval *value ,
                                                                                struct _zend_literal  const  *key ) ;
extern void __attribute__((__visibility__("default")))  rebuild_object_properties(zend_object *zobj ) ;
extern int __attribute__((__visibility__("default")))  zend_check_private(union _zend_function *fbc ,
                                                                          zend_class_entry *ce ,
                                                                          char *function_name_strval ,
                                                                          int function_name_strlen ) ;
extern int __attribute__((__visibility__("default")))  zend_check_protected(zend_class_entry *ce ,
                                                                            zend_class_entry *scope ) ;
extern int __attribute__((__visibility__("default")))  zend_check_property_access(zend_object *zobj ,
                                                                                  char *prop_info_name ,
                                                                                  int prop_info_name_len ) ;
extern void __attribute__((__visibility__("default")))  zend_std_call_user_call(int ht ,
                                                                                zval *return_value ,
                                                                                zval **return_value_ptr ,
                                                                                zval *this_ptr ,
                                                                                int return_value_used ) ;
__inline static zend_uint ( __attribute__((__always_inline__)) zval_refcount_p)(zval *pz ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[555] == 0) {
    {
    fprintf(_coverage_fout, "555\n");
    fflush(_coverage_fout);
    ___coverage_array[555] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[556] == 0) {
    {
    fprintf(_coverage_fout, "556\n");
    fflush(_coverage_fout);
    ___coverage_array[556] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = rc;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[557] == 0) {
    {
    fprintf(_coverage_fout, "557\n");
    fflush(_coverage_fout);
    ___coverage_array[557] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->refcount__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[558] == 0) {
    {
    fprintf(_coverage_fout, "558\n");
    fflush(_coverage_fout);
    ___coverage_array[558] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[559] == 0) {
    {
    fprintf(_coverage_fout, "559\n");
    fflush(_coverage_fout);
    ___coverage_array[559] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (pz->refcount__gc) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[560] == 0) {
    {
    fprintf(_coverage_fout, "560\n");
    fflush(_coverage_fout);
    ___coverage_array[560] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[561] == 0) {
    {
    fprintf(_coverage_fout, "561\n");
    fflush(_coverage_fout);
    ___coverage_array[561] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (pz->refcount__gc) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[562] == 0) {
    {
    fprintf(_coverage_fout, "562\n");
    fflush(_coverage_fout);
    ___coverage_array[562] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[563] == 0) {
    {
    fprintf(_coverage_fout, "563\n");
    fflush(_coverage_fout);
    ___coverage_array[563] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[564] == 0) {
    {
    fprintf(_coverage_fout, "564\n");
    fflush(_coverage_fout);
    ___coverage_array[564] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[565] == 0) {
    {
    fprintf(_coverage_fout, "565\n");
    fflush(_coverage_fout);
    ___coverage_array[565] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[566] == 0) {
    {
    fprintf(_coverage_fout, "566\n");
    fflush(_coverage_fout);
    ___coverage_array[566] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[567] == 0) {
    {
    fprintf(_coverage_fout, "567\n");
    fflush(_coverage_fout);
    ___coverage_array[567] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[568] == 0) {
    {
    fprintf(_coverage_fout, "568\n");
    fflush(_coverage_fout);
    ___coverage_array[568] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[569] == 0) {
    {
    fprintf(_coverage_fout, "569\n");
    fflush(_coverage_fout);
    ___coverage_array[569] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[570] == 0) {
    {
    fprintf(_coverage_fout, "570\n");
    fflush(_coverage_fout);
    ___coverage_array[570] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = isref;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[571] == 0) {
    {
    fprintf(_coverage_fout, "571\n");
    fflush(_coverage_fout);
    ___coverage_array[571] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  pz->is_ref__gc = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[572] == 0) {
    {
    fprintf(_coverage_fout, "572\n");
    fflush(_coverage_fout);
    ___coverage_array[572] = 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_block_interruptions)(void) ;
extern void __attribute__((__visibility__("default")))  (*zend_unblock_interruptions)(void) ;
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 ;
extern void __attribute__((__visibility__("default")))  zend_message_dispatcher(long message ,
                                                                                void *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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[577] == 0) {
    {
    fprintf(_coverage_fout, "577\n");
    fflush(_coverage_fout);
    ___coverage_array[577] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )z->type == 4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[573] == 0) {
      {
      fprintf(_coverage_fout, "573\n");
      fflush(_coverage_fout);
      ___coverage_array[573] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    gc_zval_possible_root(z);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[576] == 0) {
      {
      fprintf(_coverage_fout, "576\n");
      fflush(_coverage_fout);
      ___coverage_array[576] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )z->type == 5) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[574] == 0) {
        {
        fprintf(_coverage_fout, "574\n");
        fflush(_coverage_fout);
        ___coverage_array[574] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      gc_zval_possible_root(z);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[575] == 0) {
        {
        fprintf(_coverage_fout, "575\n");
        fflush(_coverage_fout);
        ___coverage_array[575] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[578] == 0) {
    {
    fprintf(_coverage_fout, "578\n");
    fflush(_coverage_fout);
    ___coverage_array[578] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[579] == 0) {
    {
    fprintf(_coverage_fout, "579\n");
    fflush(_coverage_fout);
    ___coverage_array[579] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (root->next)->prev = root->prev;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[580] == 0) {
    {
    fprintf(_coverage_fout, "580\n");
    fflush(_coverage_fout);
    ___coverage_array[580] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (root->prev)->next = root->next;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[581] == 0) {
    {
    fprintf(_coverage_fout, "581\n");
    fflush(_coverage_fout);
    ___coverage_array[581] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  root->prev = gc_globals.unused;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[582] == 0) {
    {
    fprintf(_coverage_fout, "582\n");
    fflush(_coverage_fout);
    ___coverage_array[582] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  gc_globals.unused = root;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[583] == 0) {
    {
    fprintf(_coverage_fout, "583\n");
    fflush(_coverage_fout);
    ___coverage_array[583] = 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 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[588] == 0) {
    {
    fprintf(_coverage_fout, "588\n");
    fflush(_coverage_fout);
    ___coverage_array[588] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (d > (double )2147483647L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[584] == 0) {
      {
      fprintf(_coverage_fout, "584\n");
      fflush(_coverage_fout);
      ___coverage_array[584] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((long )((unsigned long )((long long )d)));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[587] == 0) {
      {
      fprintf(_coverage_fout, "587\n");
      fflush(_coverage_fout);
      ___coverage_array[587] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (d < (double )(-0x7FFFFFFF-1)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[585] == 0) {
        {
        fprintf(_coverage_fout, "585\n");
        fflush(_coverage_fout);
        ___coverage_array[585] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((long )((unsigned long )((long long )d)));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[586] == 0) {
        {
        fprintf(_coverage_fout, "586\n");
        fflush(_coverage_fout);
        ___coverage_array[586] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[589] == 0) {
    {
    fprintf(_coverage_fout, "589\n");
    fflush(_coverage_fout);
    ___coverage_array[589] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[744] == 0) {
    {
    fprintf(_coverage_fout, "744\n");
    fflush(_coverage_fout);
    ___coverage_array[744] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  base = 10;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[745] == 0) {
    {
    fprintf(_coverage_fout, "745\n");
    fflush(_coverage_fout);
    ___coverage_array[745] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  digits = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[746] == 0) {
    {
    fprintf(_coverage_fout, "746\n");
    fflush(_coverage_fout);
    ___coverage_array[746] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dp_or_e = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[747] == 0) {
    {
    fprintf(_coverage_fout, "747\n");
    fflush(_coverage_fout);
    ___coverage_array[747] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! length) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[590] == 0) {
      {
      fprintf(_coverage_fout, "590\n");
      fflush(_coverage_fout);
      ___coverage_array[590] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((unsigned char)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[591] == 0) {
      {
      fprintf(_coverage_fout, "591\n");
      fflush(_coverage_fout);
      ___coverage_array[591] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[748] == 0) {
    {
    fprintf(_coverage_fout, "748\n");
    fflush(_coverage_fout);
    ___coverage_array[748] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[603] == 0) {
      {
      fprintf(_coverage_fout, "603\n");
      fflush(_coverage_fout);
      ___coverage_array[603] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*str == 32) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[592] == 0) {
        {
        fprintf(_coverage_fout, "592\n");
        fflush(_coverage_fout);
        ___coverage_array[592] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[602] == 0) {
        {
        fprintf(_coverage_fout, "602\n");
        fflush(_coverage_fout);
        ___coverage_array[602] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*str == 9) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[593] == 0) {
          {
          fprintf(_coverage_fout, "593\n");
          fflush(_coverage_fout);
          ___coverage_array[593] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[601] == 0) {
          {
          fprintf(_coverage_fout, "601\n");
          fflush(_coverage_fout);
          ___coverage_array[601] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*str == 10) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[594] == 0) {
            {
            fprintf(_coverage_fout, "594\n");
            fflush(_coverage_fout);
            ___coverage_array[594] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[600] == 0) {
            {
            fprintf(_coverage_fout, "600\n");
            fflush(_coverage_fout);
            ___coverage_array[600] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*str == 13) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[595] == 0) {
              {
              fprintf(_coverage_fout, "595\n");
              fflush(_coverage_fout);
              ___coverage_array[595] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[599] == 0) {
              {
              fprintf(_coverage_fout, "599\n");
              fflush(_coverage_fout);
              ___coverage_array[599] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*str == 11) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[596] == 0) {
                {
                fprintf(_coverage_fout, "596\n");
                fflush(_coverage_fout);
                ___coverage_array[596] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[598] == 0) {
                {
                fprintf(_coverage_fout, "598\n");
                fflush(_coverage_fout);
                ___coverage_array[598] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*str == 12) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[597] == 0) {
                  {
                  fprintf(_coverage_fout, "597\n");
                  fflush(_coverage_fout);
                  ___coverage_array[597] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              } else {
                break;
              }
            }
          }
        }
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[604] == 0) {
      {
      fprintf(_coverage_fout, "604\n");
      fflush(_coverage_fout);
      ___coverage_array[604] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    str ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[605] == 0) {
      {
      fprintf(_coverage_fout, "605\n");
      fflush(_coverage_fout);
      ___coverage_array[605] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length --;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[749] == 0) {
    {
    fprintf(_coverage_fout, "749\n");
    fflush(_coverage_fout);
    ___coverage_array[749] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ptr = str;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[750] == 0) {
    {
    fprintf(_coverage_fout, "750\n");
    fflush(_coverage_fout);
    ___coverage_array[750] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*ptr == 45) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[606] == 0) {
      {
      fprintf(_coverage_fout, "606\n");
      fflush(_coverage_fout);
      ___coverage_array[606] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ptr ++;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[609] == 0) {
      {
      fprintf(_coverage_fout, "609\n");
      fflush(_coverage_fout);
      ___coverage_array[609] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*ptr == 43) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[607] == 0) {
        {
        fprintf(_coverage_fout, "607\n");
        fflush(_coverage_fout);
        ___coverage_array[607] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ptr ++;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[608] == 0) {
        {
        fprintf(_coverage_fout, "608\n");
        fflush(_coverage_fout);
        ___coverage_array[608] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[751] == 0) {
    {
    fprintf(_coverage_fout, "751\n");
    fflush(_coverage_fout);
    ___coverage_array[751] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int const   )*ptr >= 48) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[678] == 0) {
      {
      fprintf(_coverage_fout, "678\n");
      fflush(_coverage_fout);
      ___coverage_array[678] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int const   )*ptr <= 57) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[673] == 0) {
        {
        fprintf(_coverage_fout, "673\n");
        fflush(_coverage_fout);
        ___coverage_array[673] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (length > 2) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[618] == 0) {
          {
          fprintf(_coverage_fout, "618\n");
          fflush(_coverage_fout);
          ___coverage_array[618] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*str == 48) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[616] == 0) {
            {
            fprintf(_coverage_fout, "616\n");
            fflush(_coverage_fout);
            ___coverage_array[616] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*(str + 1) == 120) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[610] == 0) {
              {
              fprintf(_coverage_fout, "610\n");
              fflush(_coverage_fout);
              ___coverage_array[610] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            base = 16;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[611] == 0) {
              {
              fprintf(_coverage_fout, "611\n");
              fflush(_coverage_fout);
              ___coverage_array[611] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            ptr += 2;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[615] == 0) {
              {
              fprintf(_coverage_fout, "615\n");
              fflush(_coverage_fout);
              ___coverage_array[615] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*(str + 1) == 88) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[612] == 0) {
                {
                fprintf(_coverage_fout, "612\n");
                fflush(_coverage_fout);
                ___coverage_array[612] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              base = 16;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[613] == 0) {
                {
                fprintf(_coverage_fout, "613\n");
                fflush(_coverage_fout);
                ___coverage_array[613] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              ptr += 2;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[614] == 0) {
                {
                fprintf(_coverage_fout, "614\n");
                fflush(_coverage_fout);
                ___coverage_array[614] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[617] == 0) {
            {
            fprintf(_coverage_fout, "617\n");
            fflush(_coverage_fout);
            ___coverage_array[617] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[619] == 0) {
          {
          fprintf(_coverage_fout, "619\n");
          fflush(_coverage_fout);
          ___coverage_array[619] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[674] == 0) {
        {
        fprintf(_coverage_fout, "674\n");
        fflush(_coverage_fout);
        ___coverage_array[674] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[621] == 0) {
          {
          fprintf(_coverage_fout, "621\n");
          fflush(_coverage_fout);
          ___coverage_array[621] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*ptr == 48) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[620] == 0) {
            {
            fprintf(_coverage_fout, "620\n");
            fflush(_coverage_fout);
            ___coverage_array[620] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[622] == 0) {
          {
          fprintf(_coverage_fout, "622\n");
          fflush(_coverage_fout);
          ___coverage_array[622] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ptr ++;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[675] == 0) {
        {
        fprintf(_coverage_fout, "675\n");
        fflush(_coverage_fout);
        ___coverage_array[675] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      type = (unsigned char)1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[676] == 0) {
        {
        fprintf(_coverage_fout, "676\n");
        fflush(_coverage_fout);
        ___coverage_array[676] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[656] == 0) {
          {
          fprintf(_coverage_fout, "656\n");
          fflush(_coverage_fout);
          ___coverage_array[656] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (digits >= 11) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[625] == 0) {
            {
            fprintf(_coverage_fout, "625\n");
            fflush(_coverage_fout);
            ___coverage_array[625] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (dval) {
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[624] == 0) {
              {
              fprintf(_coverage_fout, "624\n");
              fflush(_coverage_fout);
              ___coverage_array[624] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (allow_errors == 1) {
              break;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[623] == 0) {
                {
                fprintf(_coverage_fout, "623\n");
                fflush(_coverage_fout);
                ___coverage_array[623] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[626] == 0) {
            {
            fprintf(_coverage_fout, "626\n");
            fflush(_coverage_fout);
            ___coverage_array[626] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[657] == 0) {
          {
          fprintf(_coverage_fout, "657\n");
          fflush(_coverage_fout);
          ___coverage_array[657] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        check_digits: 
        if ((int const   )*ptr >= 48) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[627] == 0) {
            {
            fprintf(_coverage_fout, "627\n");
            fflush(_coverage_fout);
            ___coverage_array[627] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[655] == 0) {
            {
            fprintf(_coverage_fout, "655\n");
            fflush(_coverage_fout);
            ___coverage_array[655] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___3: /* CIL Label */ 
          if (base == 16) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[631] == 0) {
              {
              fprintf(_coverage_fout, "631\n");
              fflush(_coverage_fout);
              ___coverage_array[631] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*ptr >= 65) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[628] == 0) {
                {
                fprintf(_coverage_fout, "628\n");
                fflush(_coverage_fout);
                ___coverage_array[628] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[630] == 0) {
                {
                fprintf(_coverage_fout, "630\n");
                fflush(_coverage_fout);
                ___coverage_array[630] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[629] == 0) {
                  {
                  fprintf(_coverage_fout, "629\n");
                  fflush(_coverage_fout);
                  ___coverage_array[629] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[654] == 0) {
              {
              fprintf(_coverage_fout, "654\n");
              fflush(_coverage_fout);
              ___coverage_array[654] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _L___1: /* CIL Label */ 
            if (base == 10) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[652] == 0) {
                {
                fprintf(_coverage_fout, "652\n");
                fflush(_coverage_fout);
                ___coverage_array[652] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if ((int const   )*ptr == 46) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[632] == 0) {
                  {
                  fprintf(_coverage_fout, "632\n");
                  fflush(_coverage_fout);
                  ___coverage_array[632] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[651] == 0) {
                  {
                  fprintf(_coverage_fout, "651\n");
                  fflush(_coverage_fout);
                  ___coverage_array[651] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[650] == 0) {
                    {
                    fprintf(_coverage_fout, "650\n");
                    fflush(_coverage_fout);
                    ___coverage_array[650] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  if ((int const   )*ptr == 69) {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[648] == 0) {
                      {
                      fprintf(_coverage_fout, "648\n");
                      fflush(_coverage_fout);
                      ___coverage_array[648] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }
                    _L: /* CIL Label */ 
                    if (dp_or_e < 2) {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[644] == 0) {
                        {
                        fprintf(_coverage_fout, "644\n");
                        fflush(_coverage_fout);
                        ___coverage_array[644] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      e = ptr + 1;
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[645] == 0) {
                        {
                        fprintf(_coverage_fout, "645\n");
                        fflush(_coverage_fout);
                        ___coverage_array[645] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if ((int const   )*e == 45) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[633] == 0) {
                          {
                          fprintf(_coverage_fout, "633\n");
                          fflush(_coverage_fout);
                          ___coverage_array[633] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        tmp = e;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[634] == 0) {
                          {
                          fprintf(_coverage_fout, "634\n");
                          fflush(_coverage_fout);
                          ___coverage_array[634] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        e ++;
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[635] == 0) {
                          {
                          fprintf(_coverage_fout, "635\n");
                          fflush(_coverage_fout);
                          ___coverage_array[635] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        ptr = tmp;
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[640] == 0) {
                          {
                          fprintf(_coverage_fout, "640\n");
                          fflush(_coverage_fout);
                          ___coverage_array[640] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }
                        if ((int const   )*e == 43) {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[636] == 0) {
                            {
                            fprintf(_coverage_fout, "636\n");
                            fflush(_coverage_fout);
                            ___coverage_array[636] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          tmp = e;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[637] == 0) {
                            {
                            fprintf(_coverage_fout, "637\n");
                            fflush(_coverage_fout);
                            ___coverage_array[637] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          e ++;
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[638] == 0) {
                            {
                            fprintf(_coverage_fout, "638\n");
                            fflush(_coverage_fout);
                            ___coverage_array[638] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }
                          ptr = tmp;
                        } else {
                          {
                          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[639] == 0) {
                            {
                            fprintf(_coverage_fout, "639\n");
                            fflush(_coverage_fout);
                            ___coverage_array[639] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }

                        }
                      }
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[646] == 0) {
                        {
                        fprintf(_coverage_fout, "646\n");
                        fflush(_coverage_fout);
                        ___coverage_array[646] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }
                      if ((int const   )*e >= 48) {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[642] == 0) {
                          {
                          fprintf(_coverage_fout, "642\n");
                          fflush(_coverage_fout);
                          ___coverage_array[642] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                                 "a");
                          if (___coverage_array[641] == 0) {
                            {
                            fprintf(_coverage_fout, "641\n");
                            fflush(_coverage_fout);
                            ___coverage_array[641] = 1;
                            }
                          }
                          fclose(_coverage_fout);
                          }

                        }
                      } else {
                        {
                        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                               "a");
                        if (___coverage_array[643] == 0) {
                          {
                          fprintf(_coverage_fout, "643\n");
                          fflush(_coverage_fout);
                          ___coverage_array[643] = 1;
                          }
                        }
                        fclose(_coverage_fout);
                        }

                      }
                    } else {
                      {
                      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                             "a");
                      if (___coverage_array[647] == 0) {
                        {
                        fprintf(_coverage_fout, "647\n");
                        fflush(_coverage_fout);
                        ___coverage_array[647] = 1;
                        }
                      }
                      fclose(_coverage_fout);
                      }

                    }
                  } else {
                    {
                    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                           "a");
                    if (___coverage_array[649] == 0) {
                      {
                      fprintf(_coverage_fout, "649\n");
                      fflush(_coverage_fout);
                      ___coverage_array[649] = 1;
                      }
                    }
                    fclose(_coverage_fout);
                    }

                  }
                }
              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[653] == 0) {
                {
                fprintf(_coverage_fout, "653\n");
                fflush(_coverage_fout);
                ___coverage_array[653] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        }
        break;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[658] == 0) {
          {
          fprintf(_coverage_fout, "658\n");
          fflush(_coverage_fout);
          ___coverage_array[658] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __Cont: /* CIL Label */ 
        digits ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[659] == 0) {
          {
          fprintf(_coverage_fout, "659\n");
          fflush(_coverage_fout);
          ___coverage_array[659] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ptr ++;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[677] == 0) {
        {
        fprintf(_coverage_fout, "677\n");
        fflush(_coverage_fout);
        ___coverage_array[677] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (base == 10) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[662] == 0) {
          {
          fprintf(_coverage_fout, "662\n");
          fflush(_coverage_fout);
          ___coverage_array[662] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (digits >= 11) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[660] == 0) {
            {
            fprintf(_coverage_fout, "660\n");
            fflush(_coverage_fout);
            ___coverage_array[660] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          dp_or_e = -1;
          goto process_double;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[661] == 0) {
            {
            fprintf(_coverage_fout, "661\n");
            fflush(_coverage_fout);
            ___coverage_array[661] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[672] == 0) {
          {
          fprintf(_coverage_fout, "672\n");
          fflush(_coverage_fout);
          ___coverage_array[672] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (digits < 8) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[663] == 0) {
            {
            fprintf(_coverage_fout, "663\n");
            fflush(_coverage_fout);
            ___coverage_array[663] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[671] == 0) {
            {
            fprintf(_coverage_fout, "671\n");
            fflush(_coverage_fout);
            ___coverage_array[671] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (digits == 8) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[665] == 0) {
              {
              fprintf(_coverage_fout, "665\n");
              fflush(_coverage_fout);
              ___coverage_array[665] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((int const   )*(ptr + - digits) <= 55) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[664] == 0) {
                {
                fprintf(_coverage_fout, "664\n");
                fflush(_coverage_fout);
                ___coverage_array[664] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            } else {
              goto _L___4;
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[669] == 0) {
              {
              fprintf(_coverage_fout, "669\n");
              fflush(_coverage_fout);
              ___coverage_array[669] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _L___4: /* CIL Label */ 
            if (dval) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[666] == 0) {
                {
                fprintf(_coverage_fout, "666\n");
                fflush(_coverage_fout);
                ___coverage_array[666] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___0 = zend_hex_strtod(str, & ptr);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[667] == 0) {
                {
                fprintf(_coverage_fout, "667\n");
                fflush(_coverage_fout);
                ___coverage_array[667] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              local_dval = (double )tmp___0;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[668] == 0) {
                {
                fprintf(_coverage_fout, "668\n");
                fflush(_coverage_fout);
                ___coverage_array[668] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[670] == 0) {
              {
              fprintf(_coverage_fout, "670\n");
              fflush(_coverage_fout);
              ___coverage_array[670] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[697] == 0) {
      {
      fprintf(_coverage_fout, "697\n");
      fflush(_coverage_fout);
      ___coverage_array[697] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[695] == 0) {
        {
        fprintf(_coverage_fout, "695\n");
        fflush(_coverage_fout);
        ___coverage_array[695] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(ptr + 1) >= 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[693] == 0) {
          {
          fprintf(_coverage_fout, "693\n");
          fflush(_coverage_fout);
          ___coverage_array[693] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int const   )*(ptr + 1) <= 57) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[690] == 0) {
            {
            fprintf(_coverage_fout, "690\n");
            fflush(_coverage_fout);
            ___coverage_array[690] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          process_double: 
          type = (unsigned char)2;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[691] == 0) {
            {
            fprintf(_coverage_fout, "691\n");
            fflush(_coverage_fout);
            ___coverage_array[691] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (dval) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[679] == 0) {
              {
              fprintf(_coverage_fout, "679\n");
              fflush(_coverage_fout);
              ___coverage_array[679] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___1 = zend_strtod(str, & ptr);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[680] == 0) {
              {
              fprintf(_coverage_fout, "680\n");
              fflush(_coverage_fout);
              ___coverage_array[680] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            local_dval = (double )tmp___1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[689] == 0) {
              {
              fprintf(_coverage_fout, "689\n");
              fflush(_coverage_fout);
              ___coverage_array[689] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (allow_errors != 1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[687] == 0) {
                {
                fprintf(_coverage_fout, "687\n");
                fflush(_coverage_fout);
                ___coverage_array[687] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (dp_or_e != -1) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[683] == 0) {
                  {
                  fprintf(_coverage_fout, "683\n");
                  fflush(_coverage_fout);
                  ___coverage_array[683] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___3 = ptr;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[684] == 0) {
                  {
                  fprintf(_coverage_fout, "684\n");
                  fflush(_coverage_fout);
                  ___coverage_array[684] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                ptr ++;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[685] == 0) {
                  {
                  fprintf(_coverage_fout, "685\n");
                  fflush(_coverage_fout);
                  ___coverage_array[685] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                if ((int const   )*tmp___3 == 46) {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[681] == 0) {
                    {
                    fprintf(_coverage_fout, "681\n");
                    fflush(_coverage_fout);
                    ___coverage_array[681] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  dp_or_e = 1;
                } else {
                  {
                  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                         "a");
                  if (___coverage_array[682] == 0) {
                    {
                    fprintf(_coverage_fout, "682\n");
                    fflush(_coverage_fout);
                    ___coverage_array[682] = 1;
                    }
                  }
                  fclose(_coverage_fout);
                  }
                  dp_or_e = 2;
                }
                goto check_digits;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[686] == 0) {
                  {
                  fprintf(_coverage_fout, "686\n");
                  fflush(_coverage_fout);
                  ___coverage_array[686] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[688] == 0) {
                {
                fprintf(_coverage_fout, "688\n");
                fflush(_coverage_fout);
                ___coverage_array[688] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[692] == 0) {
            {
            fprintf(_coverage_fout, "692\n");
            fflush(_coverage_fout);
            ___coverage_array[692] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((unsigned char)0);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[694] == 0) {
          {
          fprintf(_coverage_fout, "694\n");
          fflush(_coverage_fout);
          ___coverage_array[694] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return ((unsigned char)0);
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[696] == 0) {
        {
        fprintf(_coverage_fout, "696\n");
        fflush(_coverage_fout);
        ___coverage_array[696] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((unsigned char)0);
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[752] == 0) {
    {
    fprintf(_coverage_fout, "752\n");
    fflush(_coverage_fout);
    ___coverage_array[752] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )ptr != (unsigned int )(str + length)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[702] == 0) {
      {
      fprintf(_coverage_fout, "702\n");
      fflush(_coverage_fout);
      ___coverage_array[702] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (! allow_errors) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[698] == 0) {
        {
        fprintf(_coverage_fout, "698\n");
        fflush(_coverage_fout);
        ___coverage_array[698] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((unsigned char)0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[699] == 0) {
        {
        fprintf(_coverage_fout, "699\n");
        fflush(_coverage_fout);
        ___coverage_array[699] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[703] == 0) {
      {
      fprintf(_coverage_fout, "703\n");
      fflush(_coverage_fout);
      ___coverage_array[703] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (allow_errors == -1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[700] == 0) {
        {
        fprintf(_coverage_fout, "700\n");
        fflush(_coverage_fout);
        ___coverage_array[700] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[701] == 0) {
        {
        fprintf(_coverage_fout, "701\n");
        fflush(_coverage_fout);
        ___coverage_array[701] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[704] == 0) {
      {
      fprintf(_coverage_fout, "704\n");
      fflush(_coverage_fout);
      ___coverage_array[704] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[753] == 0) {
    {
    fprintf(_coverage_fout, "753\n");
    fflush(_coverage_fout);
    ___coverage_array[753] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )type == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[737] == 0) {
      {
      fprintf(_coverage_fout, "737\n");
      fflush(_coverage_fout);
      ___coverage_array[737] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (digits == 10) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[731] == 0) {
        {
        fprintf(_coverage_fout, "731\n");
        fflush(_coverage_fout);
        ___coverage_array[731] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[716] == 0) {
          {
          fprintf(_coverage_fout, "716\n");
          fflush(_coverage_fout);
          ___coverage_array[716] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __s1_len = strlen(ptr + - digits);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[717] == 0) {
          {
          fprintf(_coverage_fout, "717\n");
          fflush(_coverage_fout);
          ___coverage_array[717] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __s2_len = strlen(long_min_digits);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[718] == 0) {
          {
          fprintf(_coverage_fout, "718\n");
          fflush(_coverage_fout);
          ___coverage_array[718] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[711] == 0) {
            {
            fprintf(_coverage_fout, "711\n");
            fflush(_coverage_fout);
            ___coverage_array[711] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (__s1_len >= 4U) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[709] == 0) {
              {
              fprintf(_coverage_fout, "709\n");
              fflush(_coverage_fout);
              ___coverage_array[709] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[705] == 0) {
                {
                fprintf(_coverage_fout, "705\n");
                fflush(_coverage_fout);
                ___coverage_array[705] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___10 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[708] == 0) {
                {
                fprintf(_coverage_fout, "708\n");
                fflush(_coverage_fout);
                ___coverage_array[708] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (__s2_len >= 4U) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[706] == 0) {
                  {
                  fprintf(_coverage_fout, "706\n");
                  fflush(_coverage_fout);
                  ___coverage_array[706] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___10 = 1;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[707] == 0) {
                  {
                  fprintf(_coverage_fout, "707\n");
                  fflush(_coverage_fout);
                  ___coverage_array[707] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                tmp___10 = 0;
              }
            }
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[710] == 0) {
              {
              fprintf(_coverage_fout, "710\n");
              fflush(_coverage_fout);
              ___coverage_array[710] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___10 = 0;
          }
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[719] == 0) {
          {
          fprintf(_coverage_fout, "719\n");
          fflush(_coverage_fout);
          ___coverage_array[719] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___10) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[712] == 0) {
            {
            fprintf(_coverage_fout, "712\n");
            fflush(_coverage_fout);
            ___coverage_array[712] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[713] == 0) {
            {
            fprintf(_coverage_fout, "713\n");
            fflush(_coverage_fout);
            ___coverage_array[713] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = tmp___5;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[714] == 0) {
            {
            fprintf(_coverage_fout, "714\n");
            fflush(_coverage_fout);
            ___coverage_array[714] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[715] == 0) {
            {
            fprintf(_coverage_fout, "715\n");
            fflush(_coverage_fout);
            ___coverage_array[715] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = tmp___8;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[720] == 0) {
          {
          fprintf(_coverage_fout, "720\n");
          fflush(_coverage_fout);
          ___coverage_array[720] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[721] == 0) {
          {
          fprintf(_coverage_fout, "721\n");
          fflush(_coverage_fout);
          ___coverage_array[721] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___9 = tmp___8;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[732] == 0) {
        {
        fprintf(_coverage_fout, "732\n");
        fflush(_coverage_fout);
        ___coverage_array[732] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      cmp = tmp___9;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[733] == 0) {
        {
        fprintf(_coverage_fout, "733\n");
        fflush(_coverage_fout);
        ___coverage_array[733] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (cmp < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[722] == 0) {
          {
          fprintf(_coverage_fout, "722\n");
          fflush(_coverage_fout);
          ___coverage_array[722] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[730] == 0) {
          {
          fprintf(_coverage_fout, "730\n");
          fflush(_coverage_fout);
          ___coverage_array[730] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (cmp == 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[724] == 0) {
            {
            fprintf(_coverage_fout, "724\n");
            fflush(_coverage_fout);
            ___coverage_array[724] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int const   )*str == 45) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[723] == 0) {
              {
              fprintf(_coverage_fout, "723\n");
              fflush(_coverage_fout);
              ___coverage_array[723] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            goto _L___8;
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[728] == 0) {
            {
            fprintf(_coverage_fout, "728\n");
            fflush(_coverage_fout);
            ___coverage_array[728] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___8: /* CIL Label */ 
          if (dval) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[725] == 0) {
              {
              fprintf(_coverage_fout, "725\n");
              fflush(_coverage_fout);
              ___coverage_array[725] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[726] == 0) {
              {
              fprintf(_coverage_fout, "726\n");
              fflush(_coverage_fout);
              ___coverage_array[726] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            *dval = (double )tmp___11;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[727] == 0) {
              {
              fprintf(_coverage_fout, "727\n");
              fflush(_coverage_fout);
              ___coverage_array[727] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[729] == 0) {
            {
            fprintf(_coverage_fout, "729\n");
            fflush(_coverage_fout);
            ___coverage_array[729] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return ((unsigned char)2);
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[734] == 0) {
        {
        fprintf(_coverage_fout, "734\n");
        fflush(_coverage_fout);
        ___coverage_array[734] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[738] == 0) {
      {
      fprintf(_coverage_fout, "738\n");
      fflush(_coverage_fout);
      ___coverage_array[738] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (lval) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[735] == 0) {
        {
        fprintf(_coverage_fout, "735\n");
        fflush(_coverage_fout);
        ___coverage_array[735] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[736] == 0) {
        {
        fprintf(_coverage_fout, "736\n");
        fflush(_coverage_fout);
        ___coverage_array[736] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[739] == 0) {
      {
      fprintf(_coverage_fout, "739\n");
      fflush(_coverage_fout);
      ___coverage_array[739] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((unsigned char)1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[742] == 0) {
      {
      fprintf(_coverage_fout, "742\n");
      fflush(_coverage_fout);
      ___coverage_array[742] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (dval) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[740] == 0) {
        {
        fprintf(_coverage_fout, "740\n");
        fflush(_coverage_fout);
        ___coverage_array[740] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *dval = local_dval;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[741] == 0) {
        {
        fprintf(_coverage_fout, "741\n");
        fflush(_coverage_fout);
        ___coverage_array[741] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[743] == 0) {
      {
      fprintf(_coverage_fout, "743\n");
      fflush(_coverage_fout);
      ___coverage_array[743] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[775] == 0) {
    {
    fprintf(_coverage_fout, "775\n");
    fflush(_coverage_fout);
    ___coverage_array[775] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = haystack;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[776] == 0) {
    {
    fprintf(_coverage_fout, "776\n");
    fflush(_coverage_fout);
    ___coverage_array[776] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ne = *(needle + (needle_len - 1));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[777] == 0) {
    {
    fprintf(_coverage_fout, "777\n");
    fflush(_coverage_fout);
    ___coverage_array[777] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (needle_len == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[754] == 0) {
      {
      fprintf(_coverage_fout, "754\n");
      fflush(_coverage_fout);
      ___coverage_array[754] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[755] == 0) {
      {
      fprintf(_coverage_fout, "755\n");
      fflush(_coverage_fout);
      ___coverage_array[755] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[756] == 0) {
      {
      fprintf(_coverage_fout, "756\n");
      fflush(_coverage_fout);
      ___coverage_array[756] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[778] == 0) {
    {
    fprintf(_coverage_fout, "778\n");
    fflush(_coverage_fout);
    ___coverage_array[778] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (needle_len > end - haystack) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[757] == 0) {
      {
      fprintf(_coverage_fout, "757\n");
      fflush(_coverage_fout);
      ___coverage_array[757] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[758] == 0) {
      {
      fprintf(_coverage_fout, "758\n");
      fflush(_coverage_fout);
      ___coverage_array[758] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[779] == 0) {
    {
    fprintf(_coverage_fout, "779\n");
    fflush(_coverage_fout);
    ___coverage_array[779] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  end -= needle_len;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[780] == 0) {
    {
    fprintf(_coverage_fout, "780\n");
    fflush(_coverage_fout);
    ___coverage_array[780] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[769] == 0) {
      {
      fprintf(_coverage_fout, "769\n");
      fflush(_coverage_fout);
      ___coverage_array[769] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )p <= (unsigned int )end) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[759] == 0) {
        {
        fprintf(_coverage_fout, "759\n");
        fflush(_coverage_fout);
        ___coverage_array[759] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[770] == 0) {
      {
      fprintf(_coverage_fout, "770\n");
      fflush(_coverage_fout);
      ___coverage_array[770] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[771] == 0) {
      {
      fprintf(_coverage_fout, "771\n");
      fflush(_coverage_fout);
      ___coverage_array[771] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = (char *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[772] == 0) {
      {
      fprintf(_coverage_fout, "772\n");
      fflush(_coverage_fout);
      ___coverage_array[772] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (p) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[765] == 0) {
        {
        fprintf(_coverage_fout, "765\n");
        fflush(_coverage_fout);
        ___coverage_array[765] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )ne == (int )*(p + (needle_len - 1))) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[762] == 0) {
          {
          fprintf(_coverage_fout, "762\n");
          fflush(_coverage_fout);
          ___coverage_array[762] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[763] == 0) {
          {
          fprintf(_coverage_fout, "763\n");
          fflush(_coverage_fout);
          ___coverage_array[763] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[760] == 0) {
            {
            fprintf(_coverage_fout, "760\n");
            fflush(_coverage_fout);
            ___coverage_array[760] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[761] == 0) {
            {
            fprintf(_coverage_fout, "761\n");
            fflush(_coverage_fout);
            ___coverage_array[761] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (p);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[764] == 0) {
          {
          fprintf(_coverage_fout, "764\n");
          fflush(_coverage_fout);
          ___coverage_array[764] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[766] == 0) {
        {
        fprintf(_coverage_fout, "766\n");
        fflush(_coverage_fout);
        ___coverage_array[766] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[773] == 0) {
      {
      fprintf(_coverage_fout, "773\n");
      fflush(_coverage_fout);
      ___coverage_array[773] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )p == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[767] == 0) {
        {
        fprintf(_coverage_fout, "767\n");
        fflush(_coverage_fout);
        ___coverage_array[767] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((char *)((void *)0));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[768] == 0) {
        {
        fprintf(_coverage_fout, "768\n");
        fflush(_coverage_fout);
        ___coverage_array[768] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[774] == 0) {
      {
      fprintf(_coverage_fout, "774\n");
      fflush(_coverage_fout);
      ___coverage_array[774] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[781] == 0) {
    {
    fprintf(_coverage_fout, "781\n");
    fflush(_coverage_fout);
    ___coverage_array[781] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[790] == 0) {
    {
    fprintf(_coverage_fout, "790\n");
    fflush(_coverage_fout);
    ___coverage_array[790] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (n <= 0U) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[782] == 0) {
      {
      fprintf(_coverage_fout, "782\n");
      fflush(_coverage_fout);
      ___coverage_array[782] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((void const   *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[783] == 0) {
      {
      fprintf(_coverage_fout, "783\n");
      fflush(_coverage_fout);
      ___coverage_array[783] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[791] == 0) {
    {
    fprintf(_coverage_fout, "791\n");
    fflush(_coverage_fout);
    ___coverage_array[791] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  e = ((unsigned char const   *)s + n) - 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[792] == 0) {
    {
    fprintf(_coverage_fout, "792\n");
    fflush(_coverage_fout);
    ___coverage_array[792] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[787] == 0) {
      {
      fprintf(_coverage_fout, "787\n");
      fflush(_coverage_fout);
      ___coverage_array[787] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[784] == 0) {
        {
        fprintf(_coverage_fout, "784\n");
        fflush(_coverage_fout);
        ___coverage_array[784] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[788] == 0) {
      {
      fprintf(_coverage_fout, "788\n");
      fflush(_coverage_fout);
      ___coverage_array[788] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[785] == 0) {
        {
        fprintf(_coverage_fout, "785\n");
        fflush(_coverage_fout);
        ___coverage_array[785] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((void const   *)e);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[786] == 0) {
        {
        fprintf(_coverage_fout, "786\n");
        fflush(_coverage_fout);
        ___coverage_array[786] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[789] == 0) {
      {
      fprintf(_coverage_fout, "789\n");
      fflush(_coverage_fout);
      ___coverage_array[789] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    e --;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[793] == 0) {
    {
    fprintf(_coverage_fout, "793\n");
    fflush(_coverage_fout);
    ___coverage_array[793] = 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(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 ) ;
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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[796] == 0) {
    {
    fprintf(_coverage_fout, "796\n");
    fflush(_coverage_fout);
    ___coverage_array[796] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )zvalue->type <= 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[794] == 0) {
      {
      fprintf(_coverage_fout, "794\n");
      fflush(_coverage_fout);
      ___coverage_array[794] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[795] == 0) {
      {
      fprintf(_coverage_fout, "795\n");
      fflush(_coverage_fout);
      ___coverage_array[795] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[797] == 0) {
    {
    fprintf(_coverage_fout, "797\n");
    fflush(_coverage_fout);
    ___coverage_array[797] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_dtor_func(zvalue);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[798] == 0) {
    {
    fprintf(_coverage_fout, "798\n");
    fflush(_coverage_fout);
    ___coverage_array[798] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[801] == 0) {
    {
    fprintf(_coverage_fout, "801\n");
    fflush(_coverage_fout);
    ___coverage_array[801] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )zvalue->type <= 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[799] == 0) {
      {
      fprintf(_coverage_fout, "799\n");
      fflush(_coverage_fout);
      ___coverage_array[799] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[800] == 0) {
      {
      fprintf(_coverage_fout, "800\n");
      fflush(_coverage_fout);
      ___coverage_array[800] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[802] == 0) {
    {
    fprintf(_coverage_fout, "802\n");
    fflush(_coverage_fout);
    ___coverage_array[802] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor_func(zvalue);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[803] == 0) {
    {
    fprintf(_coverage_fout, "803\n");
    fflush(_coverage_fout);
    ___coverage_array[803] = 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 void __attribute__((__visibility__("default")))  zend_qsort(void *base ,
                                                                   size_t nmemb ,
                                                                   size_t siz ,
                                                                   int (*compare)(void const   * ,
                                                                                  void const   * ) ) ;
extern opcode_handler_t __attribute__((__visibility__("default")))  *zend_opcode_handlers ;
extern char *zend_visibility_string(zend_uint fn_flags ) ;
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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[816] == 0) {
    {
    fprintf(_coverage_fout, "816\n");
    fflush(_coverage_fout);
    ___coverage_array[816] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (stack->top + 3 > stack->max) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[811] == 0) {
      {
      fprintf(_coverage_fout, "811\n");
      fflush(_coverage_fout);
      ___coverage_array[811] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[805] == 0) {
        {
        fprintf(_coverage_fout, "805\n");
        fflush(_coverage_fout);
        ___coverage_array[805] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      stack->max += 64;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[806] == 0) {
        {
        fprintf(_coverage_fout, "806\n");
        fflush(_coverage_fout);
        ___coverage_array[806] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (stack->top + 3 > stack->max) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[804] == 0) {
          {
          fprintf(_coverage_fout, "804\n");
          fflush(_coverage_fout);
          ___coverage_array[804] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[812] == 0) {
      {
      fprintf(_coverage_fout, "812\n");
      fflush(_coverage_fout);
      ___coverage_array[812] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (stack->persistent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[807] == 0) {
        {
        fprintf(_coverage_fout, "807\n");
        fflush(_coverage_fout);
        ___coverage_array[807] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[808] == 0) {
        {
        fprintf(_coverage_fout, "808\n");
        fflush(_coverage_fout);
        ___coverage_array[808] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[809] == 0) {
        {
        fprintf(_coverage_fout, "809\n");
        fflush(_coverage_fout);
        ___coverage_array[809] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[810] == 0) {
        {
        fprintf(_coverage_fout, "810\n");
        fflush(_coverage_fout);
        ___coverage_array[810] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[813] == 0) {
      {
      fprintf(_coverage_fout, "813\n");
      fflush(_coverage_fout);
      ___coverage_array[813] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[814] == 0) {
      {
      fprintf(_coverage_fout, "814\n");
      fflush(_coverage_fout);
      ___coverage_array[814] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[815] == 0) {
      {
      fprintf(_coverage_fout, "815\n");
      fflush(_coverage_fout);
      ___coverage_array[815] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[817] == 0) {
    {
    fprintf(_coverage_fout, "817\n");
    fflush(_coverage_fout);
    ___coverage_array[817] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top += 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[818] == 0) {
    {
    fprintf(_coverage_fout, "818\n");
    fflush(_coverage_fout);
    ___coverage_array[818] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[819] == 0) {
    {
    fprintf(_coverage_fout, "819\n");
    fflush(_coverage_fout);
    ___coverage_array[819] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[820] == 0) {
    {
    fprintf(_coverage_fout, "820\n");
    fflush(_coverage_fout);
    ___coverage_array[820] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___2 = a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[821] == 0) {
    {
    fprintf(_coverage_fout, "821\n");
    fflush(_coverage_fout);
    ___coverage_array[821] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[822] == 0) {
    {
    fprintf(_coverage_fout, "822\n");
    fflush(_coverage_fout);
    ___coverage_array[822] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[823] == 0) {
    {
    fprintf(_coverage_fout, "823\n");
    fflush(_coverage_fout);
    ___coverage_array[823] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___3 = b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[824] == 0) {
    {
    fprintf(_coverage_fout, "824\n");
    fflush(_coverage_fout);
    ___coverage_array[824] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[825] == 0) {
    {
    fprintf(_coverage_fout, "825\n");
    fflush(_coverage_fout);
    ___coverage_array[825] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[826] == 0) {
    {
    fprintf(_coverage_fout, "826\n");
    fflush(_coverage_fout);
    ___coverage_array[826] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___4 = c;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[827] == 0) {
    {
    fprintf(_coverage_fout, "827\n");
    fflush(_coverage_fout);
    ___coverage_array[827] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[840] == 0) {
    {
    fprintf(_coverage_fout, "840\n");
    fflush(_coverage_fout);
    ___coverage_array[840] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (stack->top + 2 > stack->max) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[835] == 0) {
      {
      fprintf(_coverage_fout, "835\n");
      fflush(_coverage_fout);
      ___coverage_array[835] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[829] == 0) {
        {
        fprintf(_coverage_fout, "829\n");
        fflush(_coverage_fout);
        ___coverage_array[829] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      stack->max += 64;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[830] == 0) {
        {
        fprintf(_coverage_fout, "830\n");
        fflush(_coverage_fout);
        ___coverage_array[830] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (stack->top + 2 > stack->max) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[828] == 0) {
          {
          fprintf(_coverage_fout, "828\n");
          fflush(_coverage_fout);
          ___coverage_array[828] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[836] == 0) {
      {
      fprintf(_coverage_fout, "836\n");
      fflush(_coverage_fout);
      ___coverage_array[836] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (stack->persistent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[831] == 0) {
        {
        fprintf(_coverage_fout, "831\n");
        fflush(_coverage_fout);
        ___coverage_array[831] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[832] == 0) {
        {
        fprintf(_coverage_fout, "832\n");
        fflush(_coverage_fout);
        ___coverage_array[832] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[833] == 0) {
        {
        fprintf(_coverage_fout, "833\n");
        fflush(_coverage_fout);
        ___coverage_array[833] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[834] == 0) {
        {
        fprintf(_coverage_fout, "834\n");
        fflush(_coverage_fout);
        ___coverage_array[834] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[837] == 0) {
      {
      fprintf(_coverage_fout, "837\n");
      fflush(_coverage_fout);
      ___coverage_array[837] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[838] == 0) {
      {
      fprintf(_coverage_fout, "838\n");
      fflush(_coverage_fout);
      ___coverage_array[838] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[839] == 0) {
      {
      fprintf(_coverage_fout, "839\n");
      fflush(_coverage_fout);
      ___coverage_array[839] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[841] == 0) {
    {
    fprintf(_coverage_fout, "841\n");
    fflush(_coverage_fout);
    ___coverage_array[841] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top += 2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[842] == 0) {
    {
    fprintf(_coverage_fout, "842\n");
    fflush(_coverage_fout);
    ___coverage_array[842] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[843] == 0) {
    {
    fprintf(_coverage_fout, "843\n");
    fflush(_coverage_fout);
    ___coverage_array[843] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[844] == 0) {
    {
    fprintf(_coverage_fout, "844\n");
    fflush(_coverage_fout);
    ___coverage_array[844] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___2 = a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[845] == 0) {
    {
    fprintf(_coverage_fout, "845\n");
    fflush(_coverage_fout);
    ___coverage_array[845] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[846] == 0) {
    {
    fprintf(_coverage_fout, "846\n");
    fflush(_coverage_fout);
    ___coverage_array[846] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[847] == 0) {
    {
    fprintf(_coverage_fout, "847\n");
    fflush(_coverage_fout);
    ___coverage_array[847] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___3 = b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[848] == 0) {
    {
    fprintf(_coverage_fout, "848\n");
    fflush(_coverage_fout);
    ___coverage_array[848] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[849] == 0) {
    {
    fprintf(_coverage_fout, "849\n");
    fflush(_coverage_fout);
    ___coverage_array[849] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[850] == 0) {
    {
    fprintf(_coverage_fout, "850\n");
    fflush(_coverage_fout);
    ___coverage_array[850] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *a = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[851] == 0) {
    {
    fprintf(_coverage_fout, "851\n");
    fflush(_coverage_fout);
    ___coverage_array[851] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[852] == 0) {
    {
    fprintf(_coverage_fout, "852\n");
    fflush(_coverage_fout);
    ___coverage_array[852] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *b = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[853] == 0) {
    {
    fprintf(_coverage_fout, "853\n");
    fflush(_coverage_fout);
    ___coverage_array[853] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[854] == 0) {
    {
    fprintf(_coverage_fout, "854\n");
    fflush(_coverage_fout);
    ___coverage_array[854] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *c = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[855] == 0) {
    {
    fprintf(_coverage_fout, "855\n");
    fflush(_coverage_fout);
    ___coverage_array[855] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top -= 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[856] == 0) {
    {
    fprintf(_coverage_fout, "856\n");
    fflush(_coverage_fout);
    ___coverage_array[856] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[857] == 0) {
    {
    fprintf(_coverage_fout, "857\n");
    fflush(_coverage_fout);
    ___coverage_array[857] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[858] == 0) {
    {
    fprintf(_coverage_fout, "858\n");
    fflush(_coverage_fout);
    ___coverage_array[858] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *a = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[859] == 0) {
    {
    fprintf(_coverage_fout, "859\n");
    fflush(_coverage_fout);
    ___coverage_array[859] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[860] == 0) {
    {
    fprintf(_coverage_fout, "860\n");
    fflush(_coverage_fout);
    ___coverage_array[860] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *b = *(stack->top_element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[861] == 0) {
    {
    fprintf(_coverage_fout, "861\n");
    fflush(_coverage_fout);
    ___coverage_array[861] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack->top -= 2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[862] == 0) {
    {
    fprintf(_coverage_fout, "862\n");
    fflush(_coverage_fout);
    ___coverage_array[862] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[875] == 0) {
    {
    fprintf(_coverage_fout, "875\n");
    fflush(_coverage_fout);
    ___coverage_array[875] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (stack->top + 1 > stack->max) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[870] == 0) {
      {
      fprintf(_coverage_fout, "870\n");
      fflush(_coverage_fout);
      ___coverage_array[870] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[864] == 0) {
        {
        fprintf(_coverage_fout, "864\n");
        fflush(_coverage_fout);
        ___coverage_array[864] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      stack->max += 64;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[865] == 0) {
        {
        fprintf(_coverage_fout, "865\n");
        fflush(_coverage_fout);
        ___coverage_array[865] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (stack->top + 1 > stack->max) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[863] == 0) {
          {
          fprintf(_coverage_fout, "863\n");
          fflush(_coverage_fout);
          ___coverage_array[863] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[871] == 0) {
      {
      fprintf(_coverage_fout, "871\n");
      fflush(_coverage_fout);
      ___coverage_array[871] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (stack->persistent) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[866] == 0) {
        {
        fprintf(_coverage_fout, "866\n");
        fflush(_coverage_fout);
        ___coverage_array[866] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[867] == 0) {
        {
        fprintf(_coverage_fout, "867\n");
        fflush(_coverage_fout);
        ___coverage_array[867] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[868] == 0) {
        {
        fprintf(_coverage_fout, "868\n");
        fflush(_coverage_fout);
        ___coverage_array[868] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[869] == 0) {
        {
        fprintf(_coverage_fout, "869\n");
        fflush(_coverage_fout);
        ___coverage_array[869] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (void *)tmp___0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[872] == 0) {
      {
      fprintf(_coverage_fout, "872\n");
      fflush(_coverage_fout);
      ___coverage_array[872] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->elements = (void **)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[873] == 0) {
      {
      fprintf(_coverage_fout, "873\n");
      fflush(_coverage_fout);
      ___coverage_array[873] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack->top_element = stack->elements + stack->top;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[874] == 0) {
      {
      fprintf(_coverage_fout, "874\n");
      fflush(_coverage_fout);
      ___coverage_array[874] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[876] == 0) {
    {
    fprintf(_coverage_fout, "876\n");
    fflush(_coverage_fout);
    ___coverage_array[876] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[877] == 0) {
    {
    fprintf(_coverage_fout, "877\n");
    fflush(_coverage_fout);
    ___coverage_array[877] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = stack->top_element;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[878] == 0) {
    {
    fprintf(_coverage_fout, "878\n");
    fflush(_coverage_fout);
    ___coverage_array[878] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[879] == 0) {
    {
    fprintf(_coverage_fout, "879\n");
    fflush(_coverage_fout);
    ___coverage_array[879] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___2 = ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[880] == 0) {
    {
    fprintf(_coverage_fout, "880\n");
    fflush(_coverage_fout);
    ___coverage_array[880] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[881] == 0) {
    {
    fprintf(_coverage_fout, "881\n");
    fflush(_coverage_fout);
    ___coverage_array[881] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[882] == 0) {
    {
    fprintf(_coverage_fout, "882\n");
    fflush(_coverage_fout);
    ___coverage_array[882] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (stack->top_element) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[883] == 0) {
    {
    fprintf(_coverage_fout, "883\n");
    fflush(_coverage_fout);
    ___coverage_array[883] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[884] == 0) {
    {
    fprintf(_coverage_fout, "884\n");
    fflush(_coverage_fout);
    ___coverage_array[884] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[885] == 0) {
    {
    fprintf(_coverage_fout, "885\n");
    fflush(_coverage_fout);
    ___coverage_array[885] = 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 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 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 __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 *mangled_property ,
                                                                                   int mangled_property_len ,
                                                                                   char **class_name ,
                                                                                   char **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 *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 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 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[892] == 0) {
    {
    fprintf(_coverage_fout, "892\n");
    fflush(_coverage_fout);
    ___coverage_array[892] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[890] == 0) {
      {
      fprintf(_coverage_fout, "890\n");
      fflush(_coverage_fout);
      ___coverage_array[890] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[888] == 0) {
        {
        fprintf(_coverage_fout, "888\n");
        fflush(_coverage_fout);
        ___coverage_array[888] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[886] == 0) {
          {
          fprintf(_coverage_fout, "886\n");
          fflush(_coverage_fout);
          ___coverage_array[886] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        gc_remove_zval_from_buffer(p);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[887] == 0) {
          {
          fprintf(_coverage_fout, "887\n");
          fflush(_coverage_fout);
          ___coverage_array[887] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[889] == 0) {
        {
        fprintf(_coverage_fout, "889\n");
        fflush(_coverage_fout);
        ___coverage_array[889] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _efree((void *)p);
      break;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[891] == 0) {
      {
      fprintf(_coverage_fout, "891\n");
      fflush(_coverage_fout);
      ___coverage_array[891] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[893] == 0) {
    {
    fprintf(_coverage_fout, "893\n");
    fflush(_coverage_fout);
    ___coverage_array[893] = 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 *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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[906] == 0) {
    {
    fprintf(_coverage_fout, "906\n");
    fflush(_coverage_fout);
    ___coverage_array[906] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zval_delref_p(zval_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[907] == 0) {
    {
    fprintf(_coverage_fout, "907\n");
    fflush(_coverage_fout);
    ___coverage_array[907] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[896] == 0) {
      {
      fprintf(_coverage_fout, "896\n");
      fflush(_coverage_fout);
      ___coverage_array[896] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = zval_refcount_p(zval_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[897] == 0) {
      {
      fprintf(_coverage_fout, "897\n");
      fflush(_coverage_fout);
      ___coverage_array[897] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp == 1U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[894] == 0) {
        {
        fprintf(_coverage_fout, "894\n");
        fflush(_coverage_fout);
        ___coverage_array[894] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zval_unset_isref_p(zval_ptr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[895] == 0) {
        {
        fprintf(_coverage_fout, "895\n");
        fflush(_coverage_fout);
        ___coverage_array[895] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[898] == 0) {
      {
      fprintf(_coverage_fout, "898\n");
      fflush(_coverage_fout);
      ___coverage_array[898] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    gc_zval_check_possible_root(zval_ptr);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[905] == 0) {
      {
      fprintf(_coverage_fout, "905\n");
      fflush(_coverage_fout);
      ___coverage_array[905] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[901] == 0) {
        {
        fprintf(_coverage_fout, "901\n");
        fflush(_coverage_fout);
        ___coverage_array[901] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[899] == 0) {
          {
          fprintf(_coverage_fout, "899\n");
          fflush(_coverage_fout);
          ___coverage_array[899] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        gc_remove_zval_from_buffer(zval_ptr);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[900] == 0) {
          {
          fprintf(_coverage_fout, "900\n");
          fflush(_coverage_fout);
          ___coverage_array[900] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[902] == 0) {
        {
        fprintf(_coverage_fout, "902\n");
        fflush(_coverage_fout);
        ___coverage_array[902] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _zval_dtor(zval_ptr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[903] == 0) {
        {
        fprintf(_coverage_fout, "903\n");
        fflush(_coverage_fout);
        ___coverage_array[903] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _efree((void *)zval_ptr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[904] == 0) {
        {
        fprintf(_coverage_fout, "904\n");
        fflush(_coverage_fout);
        ___coverage_array[904] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[908] == 0) {
    {
    fprintf(_coverage_fout, "908\n");
    fflush(_coverage_fout);
    ___coverage_array[908] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[938] == 0) {
    {
    fprintf(_coverage_fout, "938\n");
    fflush(_coverage_fout);
    ___coverage_array[938] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 0: 
  result = 0;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[939] == 0) {
    {
    fprintf(_coverage_fout, "939\n");
    fflush(_coverage_fout);
    ___coverage_array[939] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[909] == 0) {
      {
      fprintf(_coverage_fout, "909\n");
      fflush(_coverage_fout);
      ___coverage_array[909] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[910] == 0) {
      {
      fprintf(_coverage_fout, "910\n");
      fflush(_coverage_fout);
      ___coverage_array[910] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[940] == 0) {
    {
    fprintf(_coverage_fout, "940\n");
    fflush(_coverage_fout);
    ___coverage_array[940] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  if (op->value.dval) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[911] == 0) {
      {
      fprintf(_coverage_fout, "911\n");
      fflush(_coverage_fout);
      ___coverage_array[911] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[912] == 0) {
      {
      fprintf(_coverage_fout, "912\n");
      fflush(_coverage_fout);
      ___coverage_array[912] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[941] == 0) {
    {
    fprintf(_coverage_fout, "941\n");
    fflush(_coverage_fout);
    ___coverage_array[941] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 6: 
  if (op->value.str.len == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[913] == 0) {
      {
      fprintf(_coverage_fout, "913\n");
      fflush(_coverage_fout);
      ___coverage_array[913] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[918] == 0) {
      {
      fprintf(_coverage_fout, "918\n");
      fflush(_coverage_fout);
      ___coverage_array[918] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (op->value.str.len == 1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[916] == 0) {
        {
        fprintf(_coverage_fout, "916\n");
        fflush(_coverage_fout);
        ___coverage_array[916] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*(op->value.str.val + 0) == 48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[914] == 0) {
          {
          fprintf(_coverage_fout, "914\n");
          fflush(_coverage_fout);
          ___coverage_array[914] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result = 0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[915] == 0) {
          {
          fprintf(_coverage_fout, "915\n");
          fflush(_coverage_fout);
          ___coverage_array[915] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        result = 1;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[917] == 0) {
        {
        fprintf(_coverage_fout, "917\n");
        fflush(_coverage_fout);
        ___coverage_array[917] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      result = 1;
    }
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[942] == 0) {
    {
    fprintf(_coverage_fout, "942\n");
    fflush(_coverage_fout);
    ___coverage_array[942] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[943] == 0) {
    {
    fprintf(_coverage_fout, "943\n");
    fflush(_coverage_fout);
    ___coverage_array[943] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[919] == 0) {
      {
      fprintf(_coverage_fout, "919\n");
      fflush(_coverage_fout);
      ___coverage_array[919] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[920] == 0) {
      {
      fprintf(_coverage_fout, "920\n");
      fflush(_coverage_fout);
      ___coverage_array[920] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    result = 0;
  }
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[944] == 0) {
    {
    fprintf(_coverage_fout, "944\n");
    fflush(_coverage_fout);
    ___coverage_array[944] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 5: 
  if ((int )op->type == 5) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[936] == 0) {
      {
      fprintf(_coverage_fout, "936\n");
      fflush(_coverage_fout);
      ___coverage_array[936] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[934] == 0) {
        {
        fprintf(_coverage_fout, "934\n");
        fflush(_coverage_fout);
        ___coverage_array[934] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((op->value.obj.handlers)->cast_object) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[923] == 0) {
          {
          fprintf(_coverage_fout, "923\n");
          fflush(_coverage_fout);
          ___coverage_array[923] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[924] == 0) {
          {
          fprintf(_coverage_fout, "924\n");
          fflush(_coverage_fout);
          ___coverage_array[924] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___2 == 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[921] == 0) {
            {
            fprintf(_coverage_fout, "921\n");
            fflush(_coverage_fout);
            ___coverage_array[921] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          result = (int )tmp___1.value.lval;
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[922] == 0) {
            {
            fprintf(_coverage_fout, "922\n");
            fflush(_coverage_fout);
            ___coverage_array[922] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[933] == 0) {
          {
          fprintf(_coverage_fout, "933\n");
          fflush(_coverage_fout);
          ___coverage_array[933] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((op->value.obj.handlers)->get) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[929] == 0) {
            {
            fprintf(_coverage_fout, "929\n");
            fflush(_coverage_fout);
            ___coverage_array[929] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___4 = (*((op->value.obj.handlers)->get))(op);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[930] == 0) {
            {
            fprintf(_coverage_fout, "930\n");
            fflush(_coverage_fout);
            ___coverage_array[930] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___3 = tmp___4;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[931] == 0) {
            {
            fprintf(_coverage_fout, "931\n");
            fflush(_coverage_fout);
            ___coverage_array[931] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((int )tmp___3->type != 5) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[925] == 0) {
              {
              fprintf(_coverage_fout, "925\n");
              fflush(_coverage_fout);
              ___coverage_array[925] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            convert_to_boolean(tmp___3);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[926] == 0) {
              {
              fprintf(_coverage_fout, "926\n");
              fflush(_coverage_fout);
              ___coverage_array[926] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            result = (int )tmp___3->value.lval;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[927] == 0) {
              {
              fprintf(_coverage_fout, "927\n");
              fflush(_coverage_fout);
              ___coverage_array[927] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _zval_ptr_dtor(& tmp___3);
            break;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[928] == 0) {
              {
              fprintf(_coverage_fout, "928\n");
              fflush(_coverage_fout);
              ___coverage_array[928] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[932] == 0) {
            {
            fprintf(_coverage_fout, "932\n");
            fflush(_coverage_fout);
            ___coverage_array[932] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[935] == 0) {
        {
        fprintf(_coverage_fout, "935\n");
        fflush(_coverage_fout);
        ___coverage_array[935] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[937] == 0) {
      {
      fprintf(_coverage_fout, "937\n");
      fflush(_coverage_fout);
      ___coverage_array[937] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[945] == 0) {
    {
    fprintf(_coverage_fout, "945\n");
    fflush(_coverage_fout);
    ___coverage_array[945] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  result = 1;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[946] == 0) {
    {
    fprintf(_coverage_fout, "946\n");
    fflush(_coverage_fout);
    ___coverage_array[946] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  result = 0;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[947] == 0) {
    {
    fprintf(_coverage_fout, "947\n");
    fflush(_coverage_fout);
    ___coverage_array[947] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[948] == 0) {
    {
    fprintf(_coverage_fout, "948\n");
    fflush(_coverage_fout);
    ___coverage_array[948] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[949] == 0) {
    {
    fprintf(_coverage_fout, "949\n");
    fflush(_coverage_fout);
    ___coverage_array[949] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page = (struct _zend_vm_stack *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[950] == 0) {
    {
    fprintf(_coverage_fout, "950\n");
    fflush(_coverage_fout);
    ___coverage_array[950] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[951] == 0) {
    {
    fprintf(_coverage_fout, "951\n");
    fflush(_coverage_fout);
    ___coverage_array[951] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page->end = page->top + count;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[952] == 0) {
    {
    fprintf(_coverage_fout, "952\n");
    fflush(_coverage_fout);
    ___coverage_array[952] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  page->prev = (struct _zend_vm_stack *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[953] == 0) {
    {
    fprintf(_coverage_fout, "953\n");
    fflush(_coverage_fout);
    ___coverage_array[953] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[954] == 0) {
    {
    fprintf(_coverage_fout, "954\n");
    fflush(_coverage_fout);
    ___coverage_array[954] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[955] == 0) {
    {
    fprintf(_coverage_fout, "955\n");
    fflush(_coverage_fout);
    ___coverage_array[955] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[961] == 0) {
    {
    fprintf(_coverage_fout, "961\n");
    fflush(_coverage_fout);
    ___coverage_array[961] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  stack = executor_globals.argument_stack;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[962] == 0) {
    {
    fprintf(_coverage_fout, "962\n");
    fflush(_coverage_fout);
    ___coverage_array[962] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[957] == 0) {
      {
      fprintf(_coverage_fout, "957\n");
      fflush(_coverage_fout);
      ___coverage_array[957] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )stack != (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[956] == 0) {
        {
        fprintf(_coverage_fout, "956\n");
        fflush(_coverage_fout);
        ___coverage_array[956] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[958] == 0) {
      {
      fprintf(_coverage_fout, "958\n");
      fflush(_coverage_fout);
      ___coverage_array[958] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = stack->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[959] == 0) {
      {
      fprintf(_coverage_fout, "959\n");
      fflush(_coverage_fout);
      ___coverage_array[959] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)stack);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[960] == 0) {
      {
      fprintf(_coverage_fout, "960\n");
      fflush(_coverage_fout);
      ___coverage_array[960] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    stack = p;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[963] == 0) {
    {
    fprintf(_coverage_fout, "963\n");
    fflush(_coverage_fout);
    ___coverage_array[963] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[966] == 0) {
    {
    fprintf(_coverage_fout, "966\n");
    fflush(_coverage_fout);
    ___coverage_array[966] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (count >= 16368) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[964] == 0) {
      {
      fprintf(_coverage_fout, "964\n");
      fflush(_coverage_fout);
      ___coverage_array[964] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = count;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[965] == 0) {
      {
      fprintf(_coverage_fout, "965\n");
      fflush(_coverage_fout);
      ___coverage_array[965] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = 16368;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[967] == 0) {
    {
    fprintf(_coverage_fout, "967\n");
    fflush(_coverage_fout);
    ___coverage_array[967] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_vm_stack_new_page(tmp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[968] == 0) {
    {
    fprintf(_coverage_fout, "968\n");
    fflush(_coverage_fout);
    ___coverage_array[968] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[969] == 0) {
    {
    fprintf(_coverage_fout, "969\n");
    fflush(_coverage_fout);
    ___coverage_array[969] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p->prev = executor_globals.argument_stack;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[970] == 0) {
    {
    fprintf(_coverage_fout, "970\n");
    fflush(_coverage_fout);
    ___coverage_array[970] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  executor_globals.argument_stack = p;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[971] == 0) {
    {
    fprintf(_coverage_fout, "971\n");
    fflush(_coverage_fout);
    ___coverage_array[971] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[972] == 0) {
    {
    fprintf(_coverage_fout, "972\n");
    fflush(_coverage_fout);
    ___coverage_array[972] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[977] == 0) {
    {
    fprintf(_coverage_fout, "977\n");
    fflush(_coverage_fout);
    ___coverage_array[977] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[975] == 0) {
      {
      fprintf(_coverage_fout, "975\n");
      fflush(_coverage_fout);
      ___coverage_array[975] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[976] == 0) {
      {
      fprintf(_coverage_fout, "976\n");
      fflush(_coverage_fout);
      ___coverage_array[976] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[973] == 0) {
        {
        fprintf(_coverage_fout, "973\n");
        fflush(_coverage_fout);
        ___coverage_array[973] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_vm_stack_extend(1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[974] == 0) {
        {
        fprintf(_coverage_fout, "974\n");
        fflush(_coverage_fout);
        ___coverage_array[974] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[978] == 0) {
    {
    fprintf(_coverage_fout, "978\n");
    fflush(_coverage_fout);
    ___coverage_array[978] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = (executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[979] == 0) {
    {
    fprintf(_coverage_fout, "979\n");
    fflush(_coverage_fout);
    ___coverage_array[979] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[980] == 0) {
    {
    fprintf(_coverage_fout, "980\n");
    fflush(_coverage_fout);
    ___coverage_array[980] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp___0 = ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[981] == 0) {
    {
    fprintf(_coverage_fout, "981\n");
    fflush(_coverage_fout);
    ___coverage_array[981] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[982] == 0) {
    {
    fprintf(_coverage_fout, "982\n");
    fflush(_coverage_fout);
    ___coverage_array[982] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[983] == 0) {
    {
    fprintf(_coverage_fout, "983\n");
    fflush(_coverage_fout);
    ___coverage_array[983] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[984] == 0) {
    {
    fprintf(_coverage_fout, "984\n");
    fflush(_coverage_fout);
    ___coverage_array[984] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tmp = ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[985] == 0) {
    {
    fprintf(_coverage_fout, "985\n");
    fflush(_coverage_fout);
    ___coverage_array[985] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[990] == 0) {
    {
    fprintf(_coverage_fout, "990\n");
    fflush(_coverage_fout);
    ___coverage_array[990] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) --;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[991] == 0) {
    {
    fprintf(_coverage_fout, "991\n");
    fflush(_coverage_fout);
    ___coverage_array[991] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  el = *((executor_globals.argument_stack)->top);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[992] == 0) {
    {
    fprintf(_coverage_fout, "992\n");
    fflush(_coverage_fout);
    ___coverage_array[992] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[993] == 0) {
    {
    fprintf(_coverage_fout, "993\n");
    fflush(_coverage_fout);
    ___coverage_array[993] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[986] == 0) {
      {
      fprintf(_coverage_fout, "986\n");
      fflush(_coverage_fout);
      ___coverage_array[986] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[987] == 0) {
      {
      fprintf(_coverage_fout, "987\n");
      fflush(_coverage_fout);
      ___coverage_array[987] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[988] == 0) {
      {
      fprintf(_coverage_fout, "988\n");
      fflush(_coverage_fout);
      ___coverage_array[988] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[989] == 0) {
      {
      fprintf(_coverage_fout, "989\n");
      fflush(_coverage_fout);
      ___coverage_array[989] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[994] == 0) {
    {
    fprintf(_coverage_fout, "994\n");
    fflush(_coverage_fout);
    ___coverage_array[994] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1008] == 0) {
    {
    fprintf(_coverage_fout, "1008\n");
    fflush(_coverage_fout);
    ___coverage_array[1008] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  size = (size + (sizeof(void *) - 1U)) / sizeof(void *);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1009] == 0) {
    {
    fprintf(_coverage_fout, "1009\n");
    fflush(_coverage_fout);
    ___coverage_array[1009] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (4U > sizeof(void *)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1000] == 0) {
      {
      fprintf(_coverage_fout, "1000\n");
      fflush(_coverage_fout);
      ___coverage_array[1000] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1001] == 0) {
      {
      fprintf(_coverage_fout, "1001\n");
      fflush(_coverage_fout);
      ___coverage_array[1001] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1002] == 0) {
      {
      fprintf(_coverage_fout, "1002\n");
      fflush(_coverage_fout);
      ___coverage_array[1002] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[995] == 0) {
        {
        fprintf(_coverage_fout, "995\n");
        fflush(_coverage_fout);
        ___coverage_array[995] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_vm_stack_extend((int )size);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[996] == 0) {
        {
        fprintf(_coverage_fout, "996\n");
        fflush(_coverage_fout);
        ___coverage_array[996] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      old_top = (executor_globals.argument_stack)->top;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[997] == 0) {
        {
        fprintf(_coverage_fout, "997\n");
        fflush(_coverage_fout);
        ___coverage_array[997] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += extra;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[998] == 0) {
        {
        fprintf(_coverage_fout, "998\n");
        fflush(_coverage_fout);
        ___coverage_array[998] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *((executor_globals.argument_stack)->top) = (void *)old_top;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[999] == 0) {
        {
        fprintf(_coverage_fout, "999\n");
        fflush(_coverage_fout);
        ___coverage_array[999] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1007] == 0) {
      {
      fprintf(_coverage_fout, "1007\n");
      fflush(_coverage_fout);
      ___coverage_array[1007] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1005] == 0) {
        {
        fprintf(_coverage_fout, "1005\n");
        fflush(_coverage_fout);
        ___coverage_array[1005] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1006] == 0) {
        {
        fprintf(_coverage_fout, "1006\n");
        fflush(_coverage_fout);
        ___coverage_array[1006] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1003] == 0) {
          {
          fprintf(_coverage_fout, "1003\n");
          fflush(_coverage_fout);
          ___coverage_array[1003] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_vm_stack_extend((int )size);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1004] == 0) {
          {
          fprintf(_coverage_fout, "1004\n");
          fflush(_coverage_fout);
          ___coverage_array[1004] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1010] == 0) {
    {
    fprintf(_coverage_fout, "1010\n");
    fflush(_coverage_fout);
    ___coverage_array[1010] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ret = (void *)(executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1011] == 0) {
    {
    fprintf(_coverage_fout, "1011\n");
    fflush(_coverage_fout);
    ___coverage_array[1011] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (executor_globals.argument_stack)->top += size;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1012] == 0) {
    {
    fprintf(_coverage_fout, "1012\n");
    fflush(_coverage_fout);
    ___coverage_array[1012] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1017] == 0) {
    {
    fprintf(_coverage_fout, "1017\n");
    fflush(_coverage_fout);
    ___coverage_array[1017] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1018] == 0) {
    {
    fprintf(_coverage_fout, "1018\n");
    fflush(_coverage_fout);
    ___coverage_array[1018] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1013] == 0) {
      {
      fprintf(_coverage_fout, "1013\n");
      fflush(_coverage_fout);
      ___coverage_array[1013] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1014] == 0) {
      {
      fprintf(_coverage_fout, "1014\n");
      fflush(_coverage_fout);
      ___coverage_array[1014] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1015] == 0) {
      {
      fprintf(_coverage_fout, "1015\n");
      fflush(_coverage_fout);
      ___coverage_array[1015] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1016] == 0) {
      {
      fprintf(_coverage_fout, "1016\n");
      fflush(_coverage_fout);
      ___coverage_array[1016] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (executor_globals.argument_stack)->top = (void **)ptr;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1019] == 0) {
    {
    fprintf(_coverage_fout, "1019\n");
    fflush(_coverage_fout);
    ___coverage_array[1019] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1027] == 0) {
    {
    fprintf(_coverage_fout, "1027\n");
    fflush(_coverage_fout);
    ___coverage_array[1027] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1028] == 0) {
    {
    fprintf(_coverage_fout, "1028\n");
    fflush(_coverage_fout);
    ___coverage_array[1028] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1020] == 0) {
      {
      fprintf(_coverage_fout, "1020\n");
      fflush(_coverage_fout);
      ___coverage_array[1020] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p = executor_globals.argument_stack;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1021] == 0) {
      {
      fprintf(_coverage_fout, "1021\n");
      fflush(_coverage_fout);
      ___coverage_array[1021] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    executor_globals.argument_stack = p->prev;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1022] == 0) {
      {
      fprintf(_coverage_fout, "1022\n");
      fflush(_coverage_fout);
      ___coverage_array[1022] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)p);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1026] == 0) {
      {
      fprintf(_coverage_fout, "1026\n");
      fflush(_coverage_fout);
      ___coverage_array[1026] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (4U > sizeof(void *)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1023] == 0) {
        {
        fprintf(_coverage_fout, "1023\n");
        fflush(_coverage_fout);
        ___coverage_array[1023] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1024] == 0) {
        {
        fprintf(_coverage_fout, "1024\n");
        fflush(_coverage_fout);
        ___coverage_array[1024] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top = *((void ***)ptr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1025] == 0) {
        {
        fprintf(_coverage_fout, "1025\n");
        fflush(_coverage_fout);
        ___coverage_array[1025] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top = (void **)ptr;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1029] == 0) {
    {
    fprintf(_coverage_fout, "1029\n");
    fflush(_coverage_fout);
    ___coverage_array[1029] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1055] == 0) {
    {
    fprintf(_coverage_fout, "1055\n");
    fflush(_coverage_fout);
    ___coverage_array[1055] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1056] == 0) {
    {
    fprintf(_coverage_fout, "1056\n");
    fflush(_coverage_fout);
    ___coverage_array[1056] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1053] == 0) {
      {
      fprintf(_coverage_fout, "1053\n");
      fflush(_coverage_fout);
      ___coverage_array[1053] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1054] == 0) {
      {
      fprintf(_coverage_fout, "1054\n");
      fflush(_coverage_fout);
      ___coverage_array[1054] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1044] == 0) {
        {
        fprintf(_coverage_fout, "1044\n");
        fflush(_coverage_fout);
        ___coverage_array[1044] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L: /* CIL Label */ 
      p = executor_globals.argument_stack;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1045] == 0) {
        {
        fprintf(_coverage_fout, "1045\n");
        fflush(_coverage_fout);
        ___coverage_array[1045] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zend_vm_stack_extend(count + 1);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1046] == 0) {
        {
        fprintf(_coverage_fout, "1046\n");
        fflush(_coverage_fout);
        ___coverage_array[1046] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (executor_globals.argument_stack)->top += count;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1047] == 0) {
        {
        fprintf(_coverage_fout, "1047\n");
        fflush(_coverage_fout);
        ___coverage_array[1047] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1048] == 0) {
        {
        fprintf(_coverage_fout, "1048\n");
        fflush(_coverage_fout);
        ___coverage_array[1048] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1036] == 0) {
          {
          fprintf(_coverage_fout, "1036\n");
          fflush(_coverage_fout);
          ___coverage_array[1036] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___0 = count;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1037] == 0) {
          {
          fprintf(_coverage_fout, "1037\n");
          fflush(_coverage_fout);
          ___coverage_array[1037] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        count --;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1038] == 0) {
          {
          fprintf(_coverage_fout, "1038\n");
          fflush(_coverage_fout);
          ___coverage_array[1038] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___0 > 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1030] == 0) {
            {
            fprintf(_coverage_fout, "1030\n");
            fflush(_coverage_fout);
            ___coverage_array[1030] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1039] == 0) {
          {
          fprintf(_coverage_fout, "1039\n");
          fflush(_coverage_fout);
          ___coverage_array[1039] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        (p->top) --;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1040] == 0) {
          {
          fprintf(_coverage_fout, "1040\n");
          fflush(_coverage_fout);
          ___coverage_array[1040] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        data = *(p->top);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1041] == 0) {
          {
          fprintf(_coverage_fout, "1041\n");
          fflush(_coverage_fout);
          ___coverage_array[1041] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1042] == 0) {
          {
          fprintf(_coverage_fout, "1042\n");
          fflush(_coverage_fout);
          ___coverage_array[1042] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1031] == 0) {
            {
            fprintf(_coverage_fout, "1031\n");
            fflush(_coverage_fout);
            ___coverage_array[1031] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          r = p;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1032] == 0) {
            {
            fprintf(_coverage_fout, "1032\n");
            fflush(_coverage_fout);
            ___coverage_array[1032] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          (executor_globals.argument_stack)->prev = p->prev;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1033] == 0) {
            {
            fprintf(_coverage_fout, "1033\n");
            fflush(_coverage_fout);
            ___coverage_array[1033] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          p = p->prev;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1034] == 0) {
            {
            fprintf(_coverage_fout, "1034\n");
            fflush(_coverage_fout);
            ___coverage_array[1034] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _efree((void *)r);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1035] == 0) {
            {
            fprintf(_coverage_fout, "1035\n");
            fflush(_coverage_fout);
            ___coverage_array[1035] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1043] == 0) {
          {
          fprintf(_coverage_fout, "1043\n");
          fflush(_coverage_fout);
          ___coverage_array[1043] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1049] == 0) {
        {
        fprintf(_coverage_fout, "1049\n");
        fflush(_coverage_fout);
        ___coverage_array[1049] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (executor_globals.argument_stack)->top;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1050] == 0) {
        {
        fprintf(_coverage_fout, "1050\n");
        fflush(_coverage_fout);
        ___coverage_array[1050] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((executor_globals.argument_stack)->top) ++;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1051] == 0) {
        {
        fprintf(_coverage_fout, "1051\n");
        fflush(_coverage_fout);
        ___coverage_array[1051] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (tmp___1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1052] == 0) {
        {
        fprintf(_coverage_fout, "1052\n");
        fflush(_coverage_fout);
        ___coverage_array[1052] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1057] == 0) {
    {
    fprintf(_coverage_fout, "1057\n");
    fflush(_coverage_fout);
    ___coverage_array[1057] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1058] == 0) {
    {
    fprintf(_coverage_fout, "1058\n");
    fflush(_coverage_fout);
    ___coverage_array[1058] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = (executor_globals.argument_stack)->top;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1059] == 0) {
    {
    fprintf(_coverage_fout, "1059\n");
    fflush(_coverage_fout);
    ___coverage_array[1059] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ((executor_globals.argument_stack)->top) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1060] == 0) {
    {
    fprintf(_coverage_fout, "1060\n");
    fflush(_coverage_fout);
    ___coverage_array[1060] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1068] == 0) {
    {
    fprintf(_coverage_fout, "1068\n");
    fflush(_coverage_fout);
    ___coverage_array[1068] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = (executor_globals.argument_stack)->top - 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1069] == 0) {
    {
    fprintf(_coverage_fout, "1069\n");
    fflush(_coverage_fout);
    ___coverage_array[1069] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  delete_count = (int )((unsigned long )*p);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1070] == 0) {
    {
    fprintf(_coverage_fout, "1070\n");
    fflush(_coverage_fout);
    ___coverage_array[1070] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1062] == 0) {
      {
      fprintf(_coverage_fout, "1062\n");
      fflush(_coverage_fout);
      ___coverage_array[1062] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    delete_count --;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1063] == 0) {
      {
      fprintf(_coverage_fout, "1063\n");
      fflush(_coverage_fout);
      ___coverage_array[1063] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (delete_count >= 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1061] == 0) {
        {
        fprintf(_coverage_fout, "1061\n");
        fflush(_coverage_fout);
        ___coverage_array[1061] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1064] == 0) {
      {
      fprintf(_coverage_fout, "1064\n");
      fflush(_coverage_fout);
      ___coverage_array[1064] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    p --;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1065] == 0) {
      {
      fprintf(_coverage_fout, "1065\n");
      fflush(_coverage_fout);
      ___coverage_array[1065] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    q = *((zval **)p);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1066] == 0) {
      {
      fprintf(_coverage_fout, "1066\n");
      fflush(_coverage_fout);
      ___coverage_array[1066] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *p = (void *)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1067] == 0) {
      {
      fprintf(_coverage_fout, "1067\n");
      fflush(_coverage_fout);
      ___coverage_array[1067] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i_zval_ptr_dtor(q);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1071] == 0) {
    {
    fprintf(_coverage_fout, "1071\n");
    fflush(_coverage_fout);
    ___coverage_array[1071] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_vm_stack_free_int((void *)p);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1072] == 0) {
    {
    fprintf(_coverage_fout, "1072\n");
    fflush(_coverage_fout);
    ___coverage_array[1072] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1075] == 0) {
    {
    fprintf(_coverage_fout, "1075\n");
    fflush(_coverage_fout);
    ___coverage_array[1075] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1076] == 0) {
    {
    fprintf(_coverage_fout, "1076\n");
    fflush(_coverage_fout);
    ___coverage_array[1076] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  arg_count = (int )((unsigned long )*p);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1077] == 0) {
    {
    fprintf(_coverage_fout, "1077\n");
    fflush(_coverage_fout);
    ___coverage_array[1077] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1078] == 0) {
    {
    fprintf(_coverage_fout, "1078\n");
    fflush(_coverage_fout);
    ___coverage_array[1078] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1073] == 0) {
      {
      fprintf(_coverage_fout, "1073\n");
      fflush(_coverage_fout);
      ___coverage_array[1073] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((zval **)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1074] == 0) {
      {
      fprintf(_coverage_fout, "1074\n");
      fflush(_coverage_fout);
      ___coverage_array[1074] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1079] == 0) {
    {
    fprintf(_coverage_fout, "1079\n");
    fflush(_coverage_fout);
    ___coverage_array[1079] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1080] == 0) {
    {
    fprintf(_coverage_fout, "1080\n");
    fflush(_coverage_fout);
    ___coverage_array[1080] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_ptr_stack_2_pop(stack, & a, & b);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1081] == 0) {
    {
    fprintf(_coverage_fout, "1081\n");
    fflush(_coverage_fout);
    ___coverage_array[1081] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *object = (zval *)a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1082] == 0) {
    {
    fprintf(_coverage_fout, "1082\n");
    fflush(_coverage_fout);
    ___coverage_array[1082] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *fbc = (zend_function *)b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1083] == 0) {
    {
    fprintf(_coverage_fout, "1083\n");
    fflush(_coverage_fout);
    ___coverage_array[1083] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1084] == 0) {
    {
    fprintf(_coverage_fout, "1084\n");
    fflush(_coverage_fout);
    ___coverage_array[1084] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1085] == 0) {
    {
    fprintf(_coverage_fout, "1085\n");
    fflush(_coverage_fout);
    ___coverage_array[1085] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *called_scope = (zend_class_entry *)a;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1086] == 0) {
    {
    fprintf(_coverage_fout, "1086\n");
    fflush(_coverage_fout);
    ___coverage_array[1086] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *object = (zval *)b;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1087] == 0) {
    {
    fprintf(_coverage_fout, "1087\n");
    fflush(_coverage_fout);
    ___coverage_array[1087] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *fbc = (zend_function *)c;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1088] == 0) {
    {
    fprintf(_coverage_fout, "1088\n");
    fflush(_coverage_fout);
    ___coverage_array[1088] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
extern void execute_new_code(void) ;
extern char __attribute__((__visibility__("default")))  *get_active_class_name(char **space ) ;
extern char __attribute__((__visibility__("default")))  *get_active_function_name(void) ;
extern char __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 *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 *doc_comment ,
                                                                                int doc_comment_len ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_null(zend_class_entry *ce ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_bool(zend_class_entry *ce ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_long(zend_class_entry *ce ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ,
                                                                                  int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_double(zend_class_entry *ce ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    double value ,
                                                                                    int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_string(zend_class_entry *ce ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    char const   *value ,
                                                                                    int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_stringl(zend_class_entry *ce ,
                                                                                     char *name ,
                                                                                     int name_length ,
                                                                                     char const   *value ,
                                                                                     int value_len ,
                                                                                     int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_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 *name ,
                                                                             int name_length ,
                                                                             zval *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_null(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char *name ,
                                                                                  int name_length ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_bool(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_long(zend_class_entry *scope ,
                                                                                  zval *object ,
                                                                                  char *name ,
                                                                                  int name_length ,
                                                                                  long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_double(zend_class_entry *scope ,
                                                                                    zval *object ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    double value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_string(zend_class_entry *scope ,
                                                                                    zval *object ,
                                                                                    char *name ,
                                                                                    int name_length ,
                                                                                    char const   *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_stringl(zend_class_entry *scope ,
                                                                                     zval *object ,
                                                                                     char *name ,
                                                                                     int name_length ,
                                                                                     char const   *value ,
                                                                                     int value_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property(zend_class_entry *scope ,
                                                                                   char *name ,
                                                                                   int name_length ,
                                                                                   zval *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_null(zend_class_entry *scope ,
                                                                                        char *name ,
                                                                                        int name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_bool(zend_class_entry *scope ,
                                                                                        char *name ,
                                                                                        int name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_long(zend_class_entry *scope ,
                                                                                        char *name ,
                                                                                        int name_length ,
                                                                                        long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_double(zend_class_entry *scope ,
                                                                                          char *name ,
                                                                                          int name_length ,
                                                                                          double value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_string(zend_class_entry *scope ,
                                                                                          char *name ,
                                                                                          int name_length ,
                                                                                          char const   *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_stringl(zend_class_entry *scope ,
                                                                                           char *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 *name ,
                                                                            int name_length ,
                                                                            zend_bool silent ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_static_property(zend_class_entry *scope ,
                                                                                   char *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 *name ,
                                                                             int name_len ,
                                                                             ulong hash_value ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable(char *name ,
                                                                                   int name_len ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable_ex(char *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 size_t __attribute__((__visibility__("default")))  php_strlcpy(char *dst ,
                                                                      char const   *src ,
                                                                      size_t siz ) ;
extern size_t __attribute__((__visibility__("default")))  php_strlcat(char *dst ,
                                                                      char const   *src ,
                                                                      size_t siz ) ;
extern  __attribute__((__nothrow__)) unsigned short const   **__ctype_b_loc(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) __int32_t const   **__ctype_tolower_loc(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) __int32_t const   **__ctype_toupper_loc(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isalnum(int  ) ;
extern  __attribute__((__nothrow__)) int isalpha(int  ) ;
extern  __attribute__((__nothrow__)) int iscntrl(int  ) ;
extern  __attribute__((__nothrow__)) int isdigit(int  ) ;
extern  __attribute__((__nothrow__)) int islower(int  ) ;
extern  __attribute__((__nothrow__)) int isgraph(int  ) ;
extern  __attribute__((__nothrow__)) int isprint(int  ) ;
extern  __attribute__((__nothrow__)) int ispunct(int  ) ;
extern  __attribute__((__nothrow__)) int isspace(int  ) ;
extern  __attribute__((__nothrow__)) int isupper(int  ) ;
extern  __attribute__((__nothrow__)) int isxdigit(int  ) ;
__inline extern  __attribute__((__nothrow__)) int tolower(int __c ) ;
__inline extern  __attribute__((__nothrow__)) int toupper(int __c ) ;
extern  __attribute__((__nothrow__)) int isblank(int  ) ;
extern  __attribute__((__nothrow__)) int isctype(int __c , int __mask ) ;
extern  __attribute__((__nothrow__)) int isascii(int __c ) ;
extern  __attribute__((__nothrow__)) int toascii(int __c ) ;
extern  __attribute__((__nothrow__)) int _toupper(int  ) ;
extern  __attribute__((__nothrow__)) int _tolower(int  ) ;
__inline extern  __attribute__((__nothrow__)) int tolower(int __c ) ;
__inline extern int tolower(int __c ) 
{ __int32_t const   **tmp ;
  __int32_t tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1094] == 0) {
    {
    fprintf(_coverage_fout, "1094\n");
    fflush(_coverage_fout);
    ___coverage_array[1094] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__c >= -128) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1092] == 0) {
      {
      fprintf(_coverage_fout, "1092\n");
      fflush(_coverage_fout);
      ___coverage_array[1092] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (__c < 256) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1089] == 0) {
        {
        fprintf(_coverage_fout, "1089\n");
        fflush(_coverage_fout);
        ___coverage_array[1089] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = __ctype_tolower_loc();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1090] == 0) {
        {
        fprintf(_coverage_fout, "1090\n");
        fflush(_coverage_fout);
        ___coverage_array[1090] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = *(*tmp + __c);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1091] == 0) {
        {
        fprintf(_coverage_fout, "1091\n");
        fflush(_coverage_fout);
        ___coverage_array[1091] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = (int const   )__c;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1093] == 0) {
      {
      fprintf(_coverage_fout, "1093\n");
      fflush(_coverage_fout);
      ___coverage_array[1093] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = (int const   )__c;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1095] == 0) {
    {
    fprintf(_coverage_fout, "1095\n");
    fflush(_coverage_fout);
    ___coverage_array[1095] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) int toupper(int __c ) ;
__inline extern int toupper(int __c ) 
{ __int32_t const   **tmp ;
  __int32_t tmp___0 ;

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

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1103] == 0) {
    {
    fprintf(_coverage_fout, "1103\n");
    fflush(_coverage_fout);
    ___coverage_array[1103] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_replace_error_handling(error_handling, exception_class,
                              (zend_error_handling *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1104] == 0) {
    {
    fprintf(_coverage_fout, "1104\n");
    fflush(_coverage_fout);
    ___coverage_array[1104] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static void __attribute__((__deprecated__))  php_std_error_handling(void) 
{ 

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

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1106] == 0) {
    {
    fprintf(_coverage_fout, "1106\n");
    fflush(_coverage_fout);
    ___coverage_array[1106] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __xstat(3, (char const   *)__path, (struct stat *)__statbuf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1107] == 0) {
    {
    fprintf(_coverage_fout, "1107\n");
    fflush(_coverage_fout);
    ___coverage_array[1107] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int lstat(char const   * __restrict  __path ,
                                                        struct stat * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int lstat(char const   * __restrict  __path ,
                          struct stat * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1108] == 0) {
    {
    fprintf(_coverage_fout, "1108\n");
    fflush(_coverage_fout);
    ___coverage_array[1108] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __lxstat(3, (char const   *)__path, (struct stat *)__statbuf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1109] == 0) {
    {
    fprintf(_coverage_fout, "1109\n");
    fflush(_coverage_fout);
    ___coverage_array[1109] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstat(int __fd ,
                                                        struct stat *__statbuf )  __attribute__((__nonnull__(2))) ;
__inline extern int fstat(int __fd , struct stat *__statbuf ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1110] == 0) {
    {
    fprintf(_coverage_fout, "1110\n");
    fflush(_coverage_fout);
    ___coverage_array[1110] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __fxstat(3, __fd, __statbuf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1111] == 0) {
    {
    fprintf(_coverage_fout, "1111\n");
    fflush(_coverage_fout);
    ___coverage_array[1111] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstatat(int __fd ,
                                                          char const   * __restrict  __filename ,
                                                          struct stat * __restrict  __statbuf ,
                                                          int __flag )  __attribute__((__nonnull__(2,3))) ;
__inline extern int fstatat(int __fd , char const   * __restrict  __filename ,
                            struct stat * __restrict  __statbuf , int __flag ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1112] == 0) {
    {
    fprintf(_coverage_fout, "1112\n");
    fflush(_coverage_fout);
    ___coverage_array[1112] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __fxstatat(3, __fd, (char const   *)__filename,
                   (struct stat *)__statbuf, __flag);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1113] == 0) {
    {
    fprintf(_coverage_fout, "1113\n");
    fflush(_coverage_fout);
    ___coverage_array[1113] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int mknod(char const   *__path ,
                                                        __mode_t __mode ,
                                                        __dev_t __dev )  __attribute__((__nonnull__(1))) ;
__inline extern int mknod(char const   *__path , __mode_t __mode ,
                          __dev_t __dev ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1114] == 0) {
    {
    fprintf(_coverage_fout, "1114\n");
    fflush(_coverage_fout);
    ___coverage_array[1114] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __xmknod(1, __path, __mode, & __dev);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1115] == 0) {
    {
    fprintf(_coverage_fout, "1115\n");
    fflush(_coverage_fout);
    ___coverage_array[1115] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int mknodat(int __fd ,
                                                          char const   *__path ,
                                                          __mode_t __mode ,
                                                          __dev_t __dev )  __attribute__((__nonnull__(2))) ;
__inline extern int mknodat(int __fd , char const   *__path , __mode_t __mode ,
                            __dev_t __dev ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1116] == 0) {
    {
    fprintf(_coverage_fout, "1116\n");
    fflush(_coverage_fout);
    ___coverage_array[1116] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __xmknodat(1, __fd, __path, __mode, & __dev);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1117] == 0) {
    {
    fprintf(_coverage_fout, "1117\n");
    fflush(_coverage_fout);
    ___coverage_array[1117] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int stat64(char const   * __restrict  __path ,
                                                         struct stat64 * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int stat64(char const   * __restrict  __path ,
                           struct stat64 * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1118] == 0) {
    {
    fprintf(_coverage_fout, "1118\n");
    fflush(_coverage_fout);
    ___coverage_array[1118] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __xstat64(3, (char const   *)__path, (struct stat64 *)__statbuf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1119] == 0) {
    {
    fprintf(_coverage_fout, "1119\n");
    fflush(_coverage_fout);
    ___coverage_array[1119] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int lstat64(char const   * __restrict  __path ,
                                                          struct stat64 * __restrict  __statbuf )  __attribute__((__nonnull__(1,2))) ;
__inline extern int lstat64(char const   * __restrict  __path ,
                            struct stat64 * __restrict  __statbuf ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1120] == 0) {
    {
    fprintf(_coverage_fout, "1120\n");
    fflush(_coverage_fout);
    ___coverage_array[1120] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __lxstat64(3, (char const   *)__path, (struct stat64 *)__statbuf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1121] == 0) {
    {
    fprintf(_coverage_fout, "1121\n");
    fflush(_coverage_fout);
    ___coverage_array[1121] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstat64(int __fd ,
                                                          struct stat64 *__statbuf )  __attribute__((__nonnull__(2))) ;
__inline extern int fstat64(int __fd , struct stat64 *__statbuf ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1122] == 0) {
    {
    fprintf(_coverage_fout, "1122\n");
    fflush(_coverage_fout);
    ___coverage_array[1122] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __fxstat64(3, __fd, __statbuf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1123] == 0) {
    {
    fprintf(_coverage_fout, "1123\n");
    fflush(_coverage_fout);
    ___coverage_array[1123] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int fstatat64(int __fd ,
                                                            char const   * __restrict  __filename ,
                                                            struct stat64 * __restrict  __statbuf ,
                                                            int __flag )  __attribute__((__nonnull__(2,3))) ;
__inline extern int fstatat64(int __fd , char const   * __restrict  __filename ,
                              struct stat64 * __restrict  __statbuf ,
                              int __flag ) 
{ int tmp ;

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

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1132] == 0) {
    {
    fprintf(_coverage_fout, "1132\n");
    fflush(_coverage_fout);
    ___coverage_array[1132] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (__cmsg->cmsg_len < sizeof(struct cmsghdr )) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1126] == 0) {
      {
      fprintf(_coverage_fout, "1126\n");
      fflush(_coverage_fout);
      ___coverage_array[1126] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((struct cmsghdr *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1127] == 0) {
      {
      fprintf(_coverage_fout, "1127\n");
      fflush(_coverage_fout);
      ___coverage_array[1127] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1133] == 0) {
    {
    fprintf(_coverage_fout, "1133\n");
    fflush(_coverage_fout);
    ___coverage_array[1133] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __cmsg = (struct cmsghdr *)((unsigned char *)__cmsg + (((__cmsg->cmsg_len + sizeof(size_t )) - 1U) & ~ (sizeof(size_t ) - 1U)));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1134] == 0) {
    {
    fprintf(_coverage_fout, "1134\n");
    fflush(_coverage_fout);
    ___coverage_array[1134] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )((unsigned char *)(__cmsg + 1)) > (unsigned int )((unsigned char *)__mhdr->msg_control + __mhdr->msg_controllen)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1128] == 0) {
      {
      fprintf(_coverage_fout, "1128\n");
      fflush(_coverage_fout);
      ___coverage_array[1128] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((struct cmsghdr *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1131] == 0) {
      {
      fprintf(_coverage_fout, "1131\n");
      fflush(_coverage_fout);
      ___coverage_array[1131] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )((unsigned char *)__cmsg + (((__cmsg->cmsg_len + sizeof(size_t )) - 1U) & ~ (sizeof(size_t ) - 1U))) > (unsigned int )((unsigned char *)__mhdr->msg_control + __mhdr->msg_controllen)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1129] == 0) {
        {
        fprintf(_coverage_fout, "1129\n");
        fflush(_coverage_fout);
        ___coverage_array[1129] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((struct cmsghdr *)0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1130] == 0) {
        {
        fprintf(_coverage_fout, "1130\n");
        fflush(_coverage_fout);
        ___coverage_array[1130] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1135] == 0) {
    {
    fprintf(_coverage_fout, "1135\n");
    fflush(_coverage_fout);
    ___coverage_array[1135] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (__cmsg);
}
}
extern int recvmmsg(int __fd , struct mmsghdr *__vmessages ,
                    unsigned int __vlen , int __flags ,
                    struct timespec  const  *__tmo ) ;
extern  __attribute__((__nothrow__)) int socket(int __domain , int __type ,
                                                int __protocol ) ;
extern  __attribute__((__nothrow__)) int socketpair(int __domain , int __type ,
                                                    int __protocol , int *__fds ) ;
extern  __attribute__((__nothrow__)) int bind(int __fd ,
                                              struct sockaddr  const  * __restrict  __addr ,
                                              socklen_t __len ) ;
extern  __attribute__((__nothrow__)) int getsockname(int __fd ,
                                                     struct sockaddr * __restrict  __addr ,
                                                     socklen_t * __restrict  __len ) ;
extern int connect(int __fd , struct sockaddr  const  * __restrict  __addr ,
                   socklen_t __len ) ;
extern  __attribute__((__nothrow__)) int getpeername(int __fd ,
                                                     struct sockaddr * __restrict  __addr ,
                                                     socklen_t * __restrict  __len ) ;
extern ssize_t send(int __fd , void const   *__buf , size_t __n , int __flags ) ;
extern ssize_t recv(int __fd , void *__buf , size_t __n , int __flags ) ;
extern ssize_t sendto(int __fd , void const   *__buf , size_t __n ,
                      int __flags ,
                      struct sockaddr  const  * __restrict  __addr ,
                      socklen_t __addr_len ) ;
extern ssize_t recvfrom(int __fd , void * __restrict  __buf , size_t __n ,
                        int __flags , struct sockaddr * __restrict  __addr ,
                        socklen_t * __restrict  __addr_len ) ;
extern ssize_t sendmsg(int __fd , struct msghdr  const  *__message ,
                       int __flags ) ;
extern ssize_t recvmsg(int __fd , struct msghdr *__message , int __flags ) ;
extern  __attribute__((__nothrow__)) int getsockopt(int __fd , int __level ,
                                                    int __optname ,
                                                    void * __restrict  __optval ,
                                                    socklen_t * __restrict  __optlen ) ;
extern  __attribute__((__nothrow__)) int setsockopt(int __fd , int __level ,
                                                    int __optname ,
                                                    void const   *__optval ,
                                                    socklen_t __optlen ) ;
extern  __attribute__((__nothrow__)) int listen(int __fd , int __n ) ;
extern int accept(int __fd , struct sockaddr * __restrict  __addr ,
                  socklen_t * __restrict  __addr_len ) ;
extern int accept4(int __fd , struct sockaddr * __restrict  __addr ,
                   socklen_t * __restrict  __addr_len , int __flags ) ;
extern  __attribute__((__nothrow__)) int shutdown(int __fd , int __how ) ;
extern  __attribute__((__nothrow__)) int sockatmark(int __fd ) ;
extern  __attribute__((__nothrow__)) int isfdtype(int __fd , int __fdtype ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_register(char *protocol ,
                                                                                 php_stream_transport_factory factory ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_unregister(char *protocol ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_xport_create(char const   *name ,
                                                                                        long namelen ,
                                                                                        int options ,
                                                                                        int flags ,
                                                                                        char const   *persistent_id ,
                                                                                        struct timeval *timeout ,
                                                                                        php_stream_context *context ,
                                                                                        char **error_string ,
                                                                                        int *error_code ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_bind(php_stream *stream ,
                                                                             char const   *name ,
                                                                             long namelen ,
                                                                             char **error_text ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_connect(php_stream *stream ,
                                                                                char const   *name ,
                                                                                long namelen ,
                                                                                int asynchronous ,
                                                                                struct timeval *timeout ,
                                                                                char **error_text ,
                                                                                int *error_code ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_listen(php_stream *stream ,
                                                                               int backlog ,
                                                                               char **error_text ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_accept(php_stream *stream ,
                                                                               php_stream **client ,
                                                                               char **textaddr ,
                                                                               int *textaddrlen ,
                                                                               void **addr ,
                                                                               socklen_t *addrlen ,
                                                                               struct timeval *timeout ,
                                                                               char **error_text ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_get_name(php_stream *stream ,
                                                                                 int want_peer ,
                                                                                 char **textaddr ,
                                                                                 int *textaddrlen ,
                                                                                 void **addr ,
                                                                                 socklen_t *addrlen ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_recvfrom(php_stream *stream ,
                                                                                 char *buf ,
                                                                                 size_t buflen ,
                                                                                 long flags ,
                                                                                 void **addr ,
                                                                                 socklen_t *addrlen ,
                                                                                 char **textaddr ,
                                                                                 int *textaddrlen ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_sendto(php_stream *stream ,
                                                                               char const   *buf ,
                                                                               size_t buflen ,
                                                                               long flags ,
                                                                               void *addr ,
                                                                               socklen_t addrlen ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_shutdown(php_stream *stream ,
                                                                                 stream_shutdown_t how ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_crypto_setup(php_stream *stream ,
                                                                                     php_stream_xport_crypt_method_t crypto_method ,
                                                                                     php_stream *session_stream ) ;
extern int __attribute__((__visibility__("default")))  php_stream_xport_crypto_enable(php_stream *stream ,
                                                                                      int activate ) ;
extern HashTable __attribute__((__visibility__("default")))  *php_stream_xport_get_hash(void) ;
extern php_stream_transport_factory_func __attribute__((__visibility__("default")))  php_stream_generic_socket_factory ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_stdio_ops ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_plain_files_wrapper ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen(char const   *filename ,
                                                                                 char const   *mode ,
                                                                                 char **opened_path ,
                                                                                 int options ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_with_path(char *filename ,
                                                                                           char *mode ,
                                                                                           char *path ,
                                                                                           char **opened_path ,
                                                                                           int options ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_from_file(FILE *file ,
                                                                                           char const   *mode ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_from_fd(int fd ,
                                                                                         char const   *mode ,
                                                                                         char const   *persistent_id ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_from_pipe(FILE *file ,
                                                                                           char const   *mode ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_tmpfile(int dummy ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_fopen_temporary_file(char const   *dir ,
                                                                                                char const   *pfx ,
                                                                                                char **opened_path ) ;
extern FILE __attribute__((__visibility__("default")))  *_php_stream_open_wrapper_as_file(char *path ,
                                                                                          char *mode ,
                                                                                          int options ,
                                                                                          char **opened_path ) ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_glob_stream_wrapper ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_glob_stream_ops ;
extern char __attribute__((__visibility__("default")))  *_php_glob_stream_get_path(php_stream *stream ,
                                                                                   int copy ,
                                                                                   int *plen ) ;
extern char __attribute__((__visibility__("default")))  *_php_glob_stream_get_pattern(php_stream *stream ,
                                                                                      int copy ,
                                                                                      int *plen ) ;
extern int __attribute__((__visibility__("default")))  _php_glob_stream_get_count(php_stream *stream ,
                                                                                  int *pflags ) ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_userspace_ops ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_userspace_dir_ops ;
extern char __attribute__((__visibility__("default")))  *_php_stream_mmap_range(php_stream *stream ,
                                                                                size_t offset ,
                                                                                size_t length ,
                                                                                php_stream_mmap_operation_t mode ,
                                                                                size_t *mapped_len ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_mmap_unmap(php_stream *stream ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_mmap_unmap_ex(php_stream *stream ,
                                                                                 off_t readden ) ;
extern int __attribute__((__visibility__("default")))  _php_stream_cast(php_stream *stream ,
                                                                        int castas ,
                                                                        void **ret ,
                                                                        int show_err ) ;
extern int php_init_stream_wrappers(int module_number ) ;
extern int php_shutdown_stream_wrappers(int module_number ) ;
extern void php_shutdown_stream_hashes(void) ;
extern int zm_deactivate_streams(int type , int module_number ) ;
extern int __attribute__((__visibility__("default")))  php_register_url_stream_wrapper(char *protocol ,
                                                                                       php_stream_wrapper *wrapper ) ;
extern int __attribute__((__visibility__("default")))  php_unregister_url_stream_wrapper(char *protocol ) ;
extern int __attribute__((__visibility__("default")))  php_register_url_stream_wrapper_volatile(char *protocol ,
                                                                                                php_stream_wrapper *wrapper ) ;
extern int __attribute__((__visibility__("default")))  php_unregister_url_stream_wrapper_volatile(char *protocol ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_open_wrapper_ex(char *path ,
                                                                                           char *mode ,
                                                                                           int options ,
                                                                                           char **opened_path ,
                                                                                           php_stream_context *context ) ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  *php_stream_locate_url_wrapper(char const   *path ,
                                                                                                     char **path_for_open ,
                                                                                                     int options ) ;
extern char __attribute__((__visibility__("default")))  *php_stream_locate_eol(php_stream *stream ,
                                                                               char *buf ,
                                                                               size_t buf_len ) ;
extern void __attribute__((__visibility__("default")))  ( /* format attribute */  php_stream_wrapper_log_error)(php_stream_wrapper *wrapper ,
                                                                                                                int options ,
                                                                                                                char const   *fmt 
                                                                                                                , ...) ;
extern int __attribute__((__visibility__("default")))  _php_stream_make_seekable(php_stream *origstream ,
                                                                                 php_stream **newstream ,
                                                                                 int flags ) ;
extern HashTable __attribute__((__visibility__("default")))  *_php_stream_get_url_stream_wrappers_hash(void) ;
extern HashTable __attribute__((__visibility__("default")))  *php_stream_get_url_stream_wrappers_hash_global(void) ;
extern HashTable __attribute__((__visibility__("default")))  *_php_get_stream_filters_hash(void) ;
extern HashTable __attribute__((__visibility__("default")))  *php_get_stream_filters_hash_global(void) ;
extern php_stream_wrapper_ops *php_stream_user_wrapper_ops ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_memory_create(int mode ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_memory_open(int mode ,
                                                                                       char *buf ,
                                                                                       size_t length ) ;
extern char __attribute__((__visibility__("default")))  *_php_stream_memory_get_buffer(php_stream *stream ,
                                                                                       size_t *length ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_temp_create(int mode ,
                                                                                       size_t max_memory_usage ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_temp_open(int mode ,
                                                                                     size_t max_memory_usage ,
                                                                                     char *buf ,
                                                                                     size_t length ) ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_memory_ops ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_temp_ops ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_rfc2397_ops ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_stream_rfc2397_wrapper ;
extern struct _php_core_globals  __attribute__((__visibility__("default"))) core_globals ;
extern int __attribute__((__visibility__("default")))  zend_ini_startup(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_shutdown(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_global_shutdown(void) ;
extern int __attribute__((__visibility__("default")))  zend_ini_deactivate(void) ;
extern int __attribute__((__visibility__("default")))  zend_copy_ini_directives(void) ;
extern void __attribute__((__visibility__("default")))  zend_ini_sort_entries(void) ;
extern int __attribute__((__visibility__("default")))  zend_register_ini_entries(zend_ini_entry const   *ini_entry ,
                                                                                 int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_unregister_ini_entries(int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_refresh_caches(int stage ) ;
extern int __attribute__((__visibility__("default")))  zend_alter_ini_entry(char *name ,
                                                                            uint name_length ,
                                                                            char *new_value ,
                                                                            uint new_value_length ,
                                                                            int modify_type ,
                                                                            int stage ) ;
extern int __attribute__((__visibility__("default")))  zend_alter_ini_entry_ex(char *name ,
                                                                               uint name_length ,
                                                                               char *new_value ,
                                                                               uint new_value_length ,
                                                                               int modify_type ,
                                                                               int stage ,
                                                                               int force_change ) ;
extern int __attribute__((__visibility__("default")))  zend_restore_ini_entry(char *name ,
                                                                              uint name_length ,
                                                                              int stage ) ;
extern void __attribute__((__visibility__("default")))  display_ini_entries(zend_module_entry *module ) ;
extern long __attribute__((__visibility__("default")))  zend_ini_long(char *name ,
                                                                      uint name_length ,
                                                                      int orig ) ;
extern double __attribute__((__visibility__("default")))  zend_ini_double(char *name ,
                                                                          uint name_length ,
                                                                          int orig ) ;
extern char __attribute__((__visibility__("default")))  *zend_ini_string(char *name ,
                                                                         uint name_length ,
                                                                         int orig ) ;
extern char __attribute__((__visibility__("default")))  *zend_ini_string_ex(char *name ,
                                                                            uint name_length ,
                                                                            int orig ,
                                                                            zend_bool *exists ) ;
extern int __attribute__((__visibility__("default")))  zend_ini_register_displayer(char *name ,
                                                                                   uint name_length ,
                                                                                   void (*displayer)(zend_ini_entry *ini_entry ,
                                                                                                     int type ) ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_boolean_displayer_cb(zend_ini_entry *ini_entry ,
                                                                                      int type ) ;
extern void __attribute__((__visibility__("default")))  zend_ini_color_displayer_cb(zend_ini_entry *ini_entry ,
                                                                                    int type ) ;
extern void __attribute__((__visibility__("default")))  display_link_numbers(zend_ini_entry *ini_entry ,
                                                                             int type ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateBool(zend_ini_entry *entry ,
                                                                    char *new_value ,
                                                                    uint new_value_length ,
                                                                    void *mh_arg1 ,
                                                                    void *mh_arg2 ,
                                                                    void *mh_arg3 ,
                                                                    int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateLong(zend_ini_entry *entry ,
                                                                    char *new_value ,
                                                                    uint new_value_length ,
                                                                    void *mh_arg1 ,
                                                                    void *mh_arg2 ,
                                                                    void *mh_arg3 ,
                                                                    int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateLongGEZero(zend_ini_entry *entry ,
                                                                          char *new_value ,
                                                                          uint new_value_length ,
                                                                          void *mh_arg1 ,
                                                                          void *mh_arg2 ,
                                                                          void *mh_arg3 ,
                                                                          int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateReal(zend_ini_entry *entry ,
                                                                    char *new_value ,
                                                                    uint new_value_length ,
                                                                    void *mh_arg1 ,
                                                                    void *mh_arg2 ,
                                                                    void *mh_arg3 ,
                                                                    int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateString(zend_ini_entry *entry ,
                                                                      char *new_value ,
                                                                      uint new_value_length ,
                                                                      void *mh_arg1 ,
                                                                      void *mh_arg2 ,
                                                                      void *mh_arg3 ,
                                                                      int stage ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateStringUnempty(zend_ini_entry *entry ,
                                                                             char *new_value ,
                                                                             uint new_value_length ,
                                                                             void *mh_arg1 ,
                                                                             void *mh_arg2 ,
                                                                             void *mh_arg3 ,
                                                                             int stage ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_ini_file(zend_file_handle *fh ,
                                                                           zend_bool unbuffered_errors ,
                                                                           int scanner_mode ,
                                                                           void (*ini_parser_cb)(zval *arg1 ,
                                                                                                 zval *arg2 ,
                                                                                                 zval *arg3 ,
                                                                                                 int callback_type ,
                                                                                                 void *arg ) ,
                                                                           void *arg ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_ini_string(char *str ,
                                                                             zend_bool unbuffered_errors ,
                                                                             int scanner_mode ,
                                                                             void (*ini_parser_cb)(zval *arg1 ,
                                                                                                   zval *arg2 ,
                                                                                                   zval *arg3 ,
                                                                                                   int callback_type ,
                                                                                                   void *arg ) ,
                                                                             void *arg ) ;
extern void __attribute__((__visibility__("default")))  config_zval_dtor(zval *zvalue ) ;
extern int php_init_config(void) ;
extern int php_shutdown_config(void) ;
extern void php_ini_register_extensions(void) ;
extern zval __attribute__((__visibility__("default")))  *cfg_get_entry(char const   *name ,
                                                                       uint name_length ) ;
extern int __attribute__((__visibility__("default")))  cfg_get_long(char const   *varname ,
                                                                    long *result ) ;
extern int __attribute__((__visibility__("default")))  cfg_get_double(char const   *varname ,
                                                                      double *result ) ;
extern int __attribute__((__visibility__("default")))  cfg_get_string(char const   *varname ,
                                                                      char **result ) ;
extern int __attribute__((__visibility__("default")))  php_parse_user_ini_file(char const   *dirname ,
                                                                               char *ini_filename ,
                                                                               HashTable *target_hash ) ;
extern void __attribute__((__visibility__("default")))  php_ini_activate_config(HashTable *source_hash ,
                                                                                int modify_type ,
                                                                                int stage ) ;
extern int __attribute__((__visibility__("default")))  php_ini_has_per_dir_config(void) ;
extern int __attribute__((__visibility__("default")))  php_ini_has_per_host_config(void) ;
extern void __attribute__((__visibility__("default")))  php_ini_activate_per_dir_config(char *path ,
                                                                                        uint path_len ) ;
extern void __attribute__((__visibility__("default")))  php_ini_activate_per_host_config(char const   *host ,
                                                                                         uint host_len ) ;
extern HashTable __attribute__((__visibility__("default")))  *php_ini_get_configuration_hash(void) ;
extern int __attribute__((__visibility__("default")))  php_fopen_primary_script(zend_file_handle *file_handle ) ;
extern char __attribute__((__visibility__("default")))  *expand_filepath(char const   *filepath ,
                                                                         char *real_path ) ;
extern char __attribute__((__visibility__("default")))  *expand_filepath_ex(char const   *filepath ,
                                                                            char *real_path ,
                                                                            char const   *relative_to ,
                                                                            size_t relative_to_len ) ;
extern int __attribute__((__visibility__("default")))  php_check_open_basedir(char const   *path ) ;
extern int __attribute__((__visibility__("default")))  php_check_open_basedir_ex(char const   *path ,
                                                                                 int warn ) ;
extern int __attribute__((__visibility__("default")))  php_check_specific_open_basedir(char const   *basedir ,
                                                                                       char const   *path ) ;
extern int __attribute__((__visibility__("default")))  php_check_safe_mode_include_dir(char const   *path ) ;
extern char __attribute__((__visibility__("default")))  *php_resolve_path(char const   *filename ,
                                                                          int filename_len ,
                                                                          char const   *path ) ;
extern FILE __attribute__((__visibility__("default")))  *php_fopen_with_path(char const   *filename ,
                                                                             char const   *mode ,
                                                                             char const   *path ,
                                                                             char **opened_path ) ;
extern char __attribute__((__visibility__("default")))  *php_strip_url_passwd(char *path ) ;
extern int __attribute__((__visibility__("default")))  OnUpdateBaseDir(zend_ini_entry *entry ,
                                                                       char *new_value ,
                                                                       uint new_value_length ,
                                                                       void *mh_arg1 ,
                                                                       void *mh_arg2 ,
                                                                       void *mh_arg3 ,
                                                                       int stage ) ;
extern  __attribute__((__nothrow__)) int utime(char const   *__file ,
                                               struct utimbuf  const  *__file_times )  __attribute__((__nonnull__(1))) ;
extern DIR *opendir(char const   *__name )  __attribute__((__nonnull__(1))) ;
extern DIR *fdopendir(int __fd ) ;
extern int closedir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern struct dirent *readdir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern struct dirent64 *readdir64(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern int readdir_r(DIR * __restrict  __dirp ,
                     struct dirent * __restrict  __entry ,
                     struct dirent ** __restrict  __result )  __attribute__((__nonnull__(1,2,3))) ;
extern int readdir64_r(DIR * __restrict  __dirp ,
                       struct dirent64 * __restrict  __entry ,
                       struct dirent64 ** __restrict  __result )  __attribute__((__nonnull__(1,2,3))) ;
extern  __attribute__((__nothrow__)) void rewinddir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) void seekdir(DIR *__dirp , long __pos )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) long telldir(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) int dirfd(DIR *__dirp )  __attribute__((__nonnull__(1))) ;
extern int scandir(char const   * __restrict  __dir ,
                   struct dirent *** __restrict  __namelist ,
                   int (*__selector)(struct dirent  const  * ) ,
                   int (*__cmp)(struct dirent  const  ** ,
                                struct dirent  const  ** ) )  __attribute__((__nonnull__(1,2))) ;
extern int scandir64(char const   * __restrict  __dir ,
                     struct dirent64 *** __restrict  __namelist ,
                     int (*__selector)(struct dirent64  const  * ) ,
                     int (*__cmp)(struct dirent64  const  ** ,
                                  struct dirent64  const  ** ) )  __attribute__((__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int alphasort(struct dirent  const  **__e1 ,
                                                   struct dirent  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int alphasort64(struct dirent64  const  **__e1 ,
                                                     struct dirent64  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) __ssize_t getdirentries(int __fd ,
                                                             char * __restrict  __buf ,
                                                             size_t __nbytes ,
                                                             __off_t * __restrict  __basep )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) __ssize_t getdirentries64(int __fd ,
                                                               char * __restrict  __buf ,
                                                               size_t __nbytes ,
                                                               __off64_t * __restrict  __basep )  __attribute__((__nonnull__(2,4))) ;
extern  __attribute__((__nothrow__)) int versionsort(struct dirent  const  **__e1 ,
                                                     struct dirent  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern  __attribute__((__nothrow__)) int versionsort64(struct dirent64  const  **__e1 ,
                                                       struct dirent64  const  **__e2 )  __attribute__((__pure__,
__nonnull__(1,2))) ;
extern void __attribute__((__visibility__("default")))  virtual_cwd_startup(void) ;
extern void __attribute__((__visibility__("default")))  virtual_cwd_shutdown(void) ;
extern char __attribute__((__visibility__("default")))  *virtual_getcwd_ex(size_t *length ) ;
extern char __attribute__((__visibility__("default")))  *virtual_getcwd(char *buf ,
                                                                        size_t size ) ;
extern int __attribute__((__visibility__("default")))  virtual_chdir(char const   *path ) ;
extern int __attribute__((__visibility__("default")))  virtual_chdir_file(char const   *path ,
                                                                          int (*p_chdir)(char const   *path ) ) ;
extern int __attribute__((__visibility__("default")))  virtual_filepath(char const   *path ,
                                                                        char **filepath ) ;
extern int __attribute__((__visibility__("default")))  virtual_filepath_ex(char const   *path ,
                                                                           char **filepath ,
                                                                           int (*verify_path)(cwd_state const   * ) ) ;
extern char __attribute__((__visibility__("default")))  *virtual_realpath(char const   *path ,
                                                                          char *real_path ) ;
extern FILE __attribute__((__visibility__("default")))  *virtual_fopen(char const   *path ,
                                                                       char const   *mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_open(char const   *path ,
                                                                    int flags 
                                                                    , ...) ;
extern int __attribute__((__visibility__("default")))  virtual_creat(char const   *path ,
                                                                     mode_t mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_rename(char *oldname ,
                                                                      char *newname ) ;
extern int __attribute__((__visibility__("default")))  virtual_stat(char const   *path ,
                                                                    struct stat *buf ) ;
extern int __attribute__((__visibility__("default")))  virtual_lstat(char const   *path ,
                                                                     struct stat *buf ) ;
extern int __attribute__((__visibility__("default")))  virtual_unlink(char const   *path ) ;
extern int __attribute__((__visibility__("default")))  virtual_mkdir(char const   *pathname ,
                                                                     mode_t mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_rmdir(char const   *pathname ) ;
extern DIR __attribute__((__visibility__("default")))  *virtual_opendir(char const   *pathname ) ;
extern FILE __attribute__((__visibility__("default")))  *virtual_popen(char const   *command ,
                                                                       char const   *type ) ;
extern int __attribute__((__visibility__("default")))  virtual_access(char const   *pathname ,
                                                                      int mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_utime(char const   *filename ,
                                                                     struct utimbuf *buf ) ;
extern int __attribute__((__visibility__("default")))  virtual_chmod(char const   *filename ,
                                                                     mode_t mode ) ;
extern int __attribute__((__visibility__("default")))  virtual_chown(char const   *filename ,
                                                                     uid_t owner ,
                                                                     gid_t group ,
                                                                     int link ) ;
extern int __attribute__((__visibility__("default")))  virtual_file_ex(cwd_state *state ,
                                                                       char const   *path ,
                                                                       int (*verify_path)(cwd_state const   * ) ,
                                                                       int use_realpath ) ;
extern char __attribute__((__visibility__("default")))  *tsrm_realpath(char const   *path ,
                                                                       char *real_path ) ;
extern virtual_cwd_globals cwd_globals ;
extern void __attribute__((__visibility__("default")))  realpath_cache_clean(void) ;
extern void __attribute__((__visibility__("default")))  realpath_cache_del(char const   *path ,
                                                                           int path_len ) ;
extern realpath_cache_bucket __attribute__((__visibility__("default")))  *realpath_cache_lookup(char const   *path ,
                                                                                                int path_len ,
                                                                                                time_t t ) ;
extern int __attribute__((__visibility__("default")))  realpath_cache_size(void) ;
extern int __attribute__((__visibility__("default")))  realpath_cache_max_buckets(void) ;
extern realpath_cache_bucket __attribute__((__visibility__("default")))  **realpath_cache_get_buckets(void) ;
extern void clean_module_constants(int module_number ) ;
extern void free_zend_constant(zend_constant *c ) ;
extern int zend_startup_constants(void) ;
extern int zend_shutdown_constants(void) ;
extern void zend_register_standard_constants(void) ;
extern void clean_non_persistent_constants(void) ;
extern int __attribute__((__visibility__("default")))  zend_get_constant(char const   *name ,
                                                                         uint name_len ,
                                                                         zval *result ) ;
extern int __attribute__((__visibility__("default")))  zend_get_constant_ex(char const   *name ,
                                                                            uint name_len ,
                                                                            zval *result ,
                                                                            zend_class_entry *scope ,
                                                                            ulong flags ) ;
extern void __attribute__((__visibility__("default")))  zend_register_long_constant(char const   *name ,
                                                                                    uint name_len ,
                                                                                    long lval ,
                                                                                    int flags ,
                                                                                    int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_register_double_constant(char const   *name ,
                                                                                      uint name_len ,
                                                                                      double dval ,
                                                                                      int flags ,
                                                                                      int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_register_string_constant(char const   *name ,
                                                                                      uint name_len ,
                                                                                      char *strval ,
                                                                                      int flags ,
                                                                                      int module_number ) ;
extern void __attribute__((__visibility__("default")))  zend_register_stringl_constant(char const   *name ,
                                                                                       uint name_len ,
                                                                                       char *strval ,
                                                                                       uint strlen ,
                                                                                       int flags ,
                                                                                       int module_number ) ;
extern int __attribute__((__visibility__("default")))  zend_register_constant(zend_constant *c ) ;
extern void zend_copy_constants(HashTable *target , HashTable *sourc ) ;
extern void copy_zend_constant(zend_constant *c ) ;
extern zend_constant *zend_quick_get_constant(zend_literal const   *key ,
                                              ulong flags ) ;
extern  __attribute__((__nothrow__)) clock_t clock(void) ;
extern  __attribute__((__nothrow__)) time_t time(time_t *__timer ) ;
extern  __attribute__((__nothrow__)) double difftime(time_t __time1 ,
                                                     time_t __time0 )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) time_t mktime(struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) size_t strftime(char * __restrict  __s ,
                                                     size_t __maxsize ,
                                                     char const   * __restrict  __format ,
                                                     struct tm  const  * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) char *strptime(char const   * __restrict  __s ,
                                                    char const   * __restrict  __fmt ,
                                                    struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) size_t strftime_l(char * __restrict  __s ,
                                                       size_t __maxsize ,
                                                       char const   * __restrict  __format ,
                                                       struct tm  const  * __restrict  __tp ,
                                                       __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) char *strptime_l(char const   * __restrict  __s ,
                                                      char const   * __restrict  __fmt ,
                                                      struct tm *__tp ,
                                                      __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) struct tm *gmtime(time_t const   *__timer ) ;
extern  __attribute__((__nothrow__)) struct tm *localtime(time_t const   *__timer ) ;
extern  __attribute__((__nothrow__)) struct tm *gmtime_r(time_t const   * __restrict  __timer ,
                                                         struct tm * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) struct tm *localtime_r(time_t const   * __restrict  __timer ,
                                                            struct tm * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) char *asctime(struct tm  const  *__tp ) ;
extern  __attribute__((__nothrow__)) char *ctime(time_t const   *__timer ) ;
extern  __attribute__((__nothrow__)) char *asctime_r(struct tm  const  * __restrict  __tp ,
                                                     char * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) char *ctime_r(time_t const   * __restrict  __timer ,
                                                   char * __restrict  __buf ) ;
extern char *__tzname[2] ;
extern int __daylight ;
extern long __timezone ;
extern char *tzname[2] ;
extern  __attribute__((__nothrow__)) void tzset(void) ;
extern int daylight ;
extern long timezone ;
extern  __attribute__((__nothrow__)) int stime(time_t const   *__when ) ;
extern  __attribute__((__nothrow__)) time_t timegm(struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) time_t timelocal(struct tm *__tp ) ;
extern  __attribute__((__nothrow__)) int dysize(int __year )  __attribute__((__const__)) ;
extern int nanosleep(struct timespec  const  *__requested_time ,
                     struct timespec *__remaining ) ;
extern  __attribute__((__nothrow__)) int clock_getres(clockid_t __clock_id ,
                                                      struct timespec *__res ) ;
extern  __attribute__((__nothrow__)) int clock_gettime(clockid_t __clock_id ,
                                                       struct timespec *__tp ) ;
extern  __attribute__((__nothrow__)) int clock_settime(clockid_t __clock_id ,
                                                       struct timespec  const  *__tp ) ;
extern int clock_nanosleep(clockid_t __clock_id , int __flags ,
                           struct timespec  const  *__req ,
                           struct timespec *__rem ) ;
extern  __attribute__((__nothrow__)) int clock_getcpuclockid(pid_t __pid ,
                                                             clockid_t *__clock_id ) ;
extern  __attribute__((__nothrow__)) int timer_create(clockid_t __clock_id ,
                                                      struct sigevent * __restrict  __evp ,
                                                      timer_t * __restrict  __timerid ) ;
extern  __attribute__((__nothrow__)) int timer_delete(timer_t __timerid ) ;
extern  __attribute__((__nothrow__)) int timer_settime(timer_t __timerid ,
                                                       int __flags ,
                                                       struct itimerspec  const  * __restrict  __value ,
                                                       struct itimerspec * __restrict  __ovalue ) ;
extern  __attribute__((__nothrow__)) int timer_gettime(timer_t __timerid ,
                                                       struct itimerspec *__value ) ;
extern  __attribute__((__nothrow__)) int timer_getoverrun(timer_t __timerid ) ;
extern int getdate_err ;
extern struct tm *getdate(char const   *__string ) ;
extern int getdate_r(char const   * __restrict  __string ,
                     struct tm * __restrict  __resbufp ) ;
extern sapi_module_struct __attribute__((__visibility__("default")))  sapi_module ;
extern sapi_globals_struct __attribute__((__visibility__("default")))  sapi_globals ;
extern void __attribute__((__visibility__("default")))  sapi_startup(sapi_module_struct *sf ) ;
extern void __attribute__((__visibility__("default")))  sapi_shutdown(void) ;
extern void __attribute__((__visibility__("default")))  sapi_activate(void) ;
extern void __attribute__((__visibility__("default")))  sapi_deactivate(void) ;
extern void __attribute__((__visibility__("default")))  sapi_initialize_empty_request(void) ;
extern int __attribute__((__visibility__("default")))  sapi_header_op(sapi_header_op_enum op ,
                                                                      void *arg ) ;
extern int __attribute__((__visibility__("default")))  sapi_add_header_ex(char *header_line ,
                                                                          uint header_line_len ,
                                                                          zend_bool duplicate ,
                                                                          zend_bool replace ) ;
extern int __attribute__((__visibility__("default")))  sapi_send_headers(void) ;
extern void __attribute__((__visibility__("default")))  sapi_free_header(sapi_header_struct *sapi_header ) ;
extern void __attribute__((__visibility__("default")))  sapi_handle_post(void *arg ) ;
extern int __attribute__((__visibility__("default")))  sapi_register_post_entries(sapi_post_entry *post_entry ) ;
extern int __attribute__((__visibility__("default")))  sapi_register_post_entry(sapi_post_entry *post_entry ) ;
extern void __attribute__((__visibility__("default")))  sapi_unregister_post_entry(sapi_post_entry *post_entry ) ;
extern int __attribute__((__visibility__("default")))  sapi_register_default_post_reader(void (*default_post_reader)(void) ) ;
extern int __attribute__((__visibility__("default")))  sapi_register_treat_data(void (*treat_data)(int arg ,
                                                                                                   char *str ,
                                                                                                   zval *destArray ) ) ;
extern int __attribute__((__visibility__("default")))  sapi_register_input_filter(unsigned int (*input_filter)(int arg ,
                                                                                                               char *var ,
                                                                                                               char **val ,
                                                                                                               unsigned int val_len ,
                                                                                                               unsigned int *new_val_len ) ,
                                                                                  unsigned int (*input_filter_init)(void) ) ;
extern int __attribute__((__visibility__("default")))  sapi_flush(void) ;
extern struct stat  __attribute__((__visibility__("default"))) *sapi_get_stat(void) ;
extern char __attribute__((__visibility__("default")))  *sapi_getenv(char *name ,
                                                                     size_t name_len ) ;
extern char __attribute__((__visibility__("default")))  *sapi_get_default_content_type(void) ;
extern void __attribute__((__visibility__("default")))  sapi_get_default_content_type_header(sapi_header_struct *default_header ) ;
extern size_t __attribute__((__visibility__("default")))  sapi_apply_default_charset(char **mimetype ,
                                                                                     size_t len ) ;
extern void __attribute__((__visibility__("default")))  sapi_activate_headers_only(void) ;
extern int __attribute__((__visibility__("default")))  sapi_get_fd(int *fd ) ;
extern int __attribute__((__visibility__("default")))  sapi_force_http_10(void) ;
extern int __attribute__((__visibility__("default")))  sapi_get_target_uid(uid_t * ) ;
extern int __attribute__((__visibility__("default")))  sapi_get_target_gid(gid_t * ) ;
extern double __attribute__((__visibility__("default")))  sapi_get_request_time(void) ;
extern void __attribute__((__visibility__("default")))  sapi_terminate_process(void) ;
extern void __attribute__((__visibility__("default")))  sapi_read_standard_form_data(void) ;
extern void __attribute__((__visibility__("default")))  php_default_post_reader(void) ;
extern void __attribute__((__visibility__("default")))  php_default_treat_data(int arg ,
                                                                               char *str ,
                                                                               zval *destArray ) ;
extern unsigned int __attribute__((__visibility__("default")))  php_default_input_filter(int arg ,
                                                                                         char *var ,
                                                                                         char **val ,
                                                                                         unsigned int val_len ,
                                                                                         unsigned int *new_val_len ) ;
extern int __attribute__((__visibility__("default")))  php_request_startup(void) ;
extern void __attribute__((__visibility__("default")))  php_request_shutdown(void *dummy ) ;
extern void __attribute__((__visibility__("default")))  php_request_shutdown_for_exec(void *dummy ) ;
extern int __attribute__((__visibility__("default")))  php_module_startup(sapi_module_struct *sf ,
                                                                          zend_module_entry *additional_modules ,
                                                                          uint num_additional_modules ) ;
extern void __attribute__((__visibility__("default")))  php_module_shutdown(void) ;
extern void __attribute__((__visibility__("default")))  php_module_shutdown_for_exec(void) ;
extern int __attribute__((__visibility__("default")))  php_module_shutdown_wrapper(sapi_module_struct *sapi_globals ) ;
extern int __attribute__((__visibility__("default")))  php_request_startup_for_hook(void) ;
extern int __attribute__((__visibility__("default")))  php_register_extensions(zend_module_entry **ptr ,
                                                                               int count ) ;
extern int __attribute__((__visibility__("default")))  php_execute_script(zend_file_handle *primary_file ) ;
extern int __attribute__((__visibility__("default")))  php_execute_simple_script(zend_file_handle *primary_file ,
                                                                                 zval **ret ) ;
extern int __attribute__((__visibility__("default")))  php_handle_special_queries(void) ;
extern int __attribute__((__visibility__("default")))  php_lint_script(zend_file_handle *file ) ;
extern void __attribute__((__visibility__("default")))  php_handle_aborted_connection(void) ;
extern int __attribute__((__visibility__("default")))  php_handle_auth_data(char const   *auth ) ;
extern void __attribute__((__visibility__("default")))  php_html_puts(char const   *str ,
                                                                      uint siz ) ;
extern int __attribute__((__visibility__("default")))  php_stream_open_for_zend_ex(char const   *filename ,
                                                                                   zend_file_handle *handle ,
                                                                                   int mode ) ;
extern void php_call_shutdown_functions(void) ;
extern void php_free_shutdown_functions(void) ;
extern int php_init_environ(void) ;
extern int php_shutdown_environ(void) ;
extern void zif_phpversion(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
extern void zif_phpinfo(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_phpcredits(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
extern void zif_php_logo_guid(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_php_real_logo_guid(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_zend_logo_guid(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_php_egg_logo_guid(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void zif_php_sapi_name(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_php_uname(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_php_ini_scanned_files(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_php_ini_loaded_file(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern char __attribute__((__visibility__("default")))  *php_info_html_esc(char *string ) ;
extern void __attribute__((__visibility__("default")))  php_info_html_esc_write(char *string ,
                                                                                int str_len ) ;
extern void __attribute__((__visibility__("default")))  php_print_info_htmlhead(void) ;
extern void __attribute__((__visibility__("default")))  php_print_info(int flag ) ;
extern void __attribute__((__visibility__("default")))  php_print_style(void) ;
extern void __attribute__((__visibility__("default")))  php_info_print_style(void) ;
extern void __attribute__((__visibility__("default")))  php_info_print_table_colspan_header(int num_cols ,
                                                                                            char *header ) ;
extern void __attribute__((__visibility__("default")))  php_info_print_table_header(int num_cols 
                                                                                    , ...) ;
extern void __attribute__((__visibility__("default")))  php_info_print_table_row(int num_cols 
                                                                                 , ...) ;
extern void __attribute__((__visibility__("default")))  php_info_print_table_row_ex(int num_cols ,
                                                                                    char const   * 
                                                                                    , ...) ;
extern void __attribute__((__visibility__("default")))  php_info_print_table_start(void) ;
extern void __attribute__((__visibility__("default")))  php_info_print_table_end(void) ;
extern void __attribute__((__visibility__("default")))  php_info_print_box_start(int bg ) ;
extern void __attribute__((__visibility__("default")))  php_info_print_box_end(void) ;
extern void __attribute__((__visibility__("default")))  php_info_print_hr(void) ;
extern void __attribute__((__visibility__("default")))  php_info_print_module(zend_module_entry *module ) ;
extern char __attribute__((__visibility__("default")))  *php_logo_guid(void) ;
extern char __attribute__((__visibility__("default")))  *php_get_uname(char mode ) ;
extern void register_phpinfo_constants(int type , int module_number ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcscpy(wchar_t * __restrict  __dest ,
                                                     wchar_t const   * __restrict  __src ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcsncpy(wchar_t * __restrict  __dest ,
                                                      wchar_t const   * __restrict  __src ,
                                                      size_t __n ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcscat(wchar_t * __restrict  __dest ,
                                                     wchar_t const   * __restrict  __src ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcsncat(wchar_t * __restrict  __dest ,
                                                      wchar_t const   * __restrict  __src ,
                                                      size_t __n ) ;
extern  __attribute__((__nothrow__)) int wcscmp(wchar_t const   *__s1 ,
                                                wchar_t const   *__s2 )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) int wcsncmp(wchar_t const   *__s1 ,
                                                 wchar_t const   *__s2 ,
                                                 size_t __n )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) int wcscasecmp(wchar_t const   *__s1 ,
                                                    wchar_t const   *__s2 ) ;
extern  __attribute__((__nothrow__)) int wcsncasecmp(wchar_t const   *__s1 ,
                                                     wchar_t const   *__s2 ,
                                                     size_t __n ) ;
extern  __attribute__((__nothrow__)) int wcscasecmp_l(wchar_t const   *__s1 ,
                                                      wchar_t const   *__s2 ,
                                                      __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) int wcsncasecmp_l(wchar_t const   *__s1 ,
                                                       wchar_t const   *__s2 ,
                                                       size_t __n ,
                                                       __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) int wcscoll(wchar_t const   *__s1 ,
                                                 wchar_t const   *__s2 ) ;
extern  __attribute__((__nothrow__)) size_t wcsxfrm(wchar_t * __restrict  __s1 ,
                                                    wchar_t const   * __restrict  __s2 ,
                                                    size_t __n ) ;
extern  __attribute__((__nothrow__)) int wcscoll_l(wchar_t const   *__s1 ,
                                                   wchar_t const   *__s2 ,
                                                   __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) size_t wcsxfrm_l(wchar_t *__s1 ,
                                                      wchar_t const   *__s2 ,
                                                      size_t __n ,
                                                      __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcsdup(wchar_t const   *__s )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcschr(wchar_t const   *__wcs ,
                                                     wchar_t __wc )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcsrchr(wchar_t const   *__wcs ,
                                                      wchar_t __wc )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcschrnul(wchar_t const   *__s ,
                                                        wchar_t __wc )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) size_t wcscspn(wchar_t const   *__wcs ,
                                                    wchar_t const   *__reject )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) size_t wcsspn(wchar_t const   *__wcs ,
                                                   wchar_t const   *__accept )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcspbrk(wchar_t const   *__wcs ,
                                                      wchar_t const   *__accept )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcsstr(wchar_t const   *__haystack ,
                                                     wchar_t const   *__needle )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcstok(wchar_t * __restrict  __s ,
                                                     wchar_t const   * __restrict  __delim ,
                                                     wchar_t ** __restrict  __ptr ) ;
extern  __attribute__((__nothrow__)) size_t wcslen(wchar_t const   *__s )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wcswcs(wchar_t const   *__haystack ,
                                                     wchar_t const   *__needle )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) size_t wcsnlen(wchar_t const   *__s ,
                                                    size_t __maxlen )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wmemchr(wchar_t const   *__s ,
                                                      wchar_t __c , size_t __n )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) int wmemcmp(wchar_t const   * __restrict  __s1 ,
                                                 wchar_t const   * __restrict  __s2 ,
                                                 size_t __n )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) wchar_t *wmemcpy(wchar_t * __restrict  __s1 ,
                                                      wchar_t const   * __restrict  __s2 ,
                                                      size_t __n ) ;
extern  __attribute__((__nothrow__)) wchar_t *wmemmove(wchar_t *__s1 ,
                                                       wchar_t const   *__s2 ,
                                                       size_t __n ) ;
extern  __attribute__((__nothrow__)) wchar_t *wmemset(wchar_t *__s ,
                                                      wchar_t __c , size_t __n ) ;
extern  __attribute__((__nothrow__)) wchar_t *wmempcpy(wchar_t * __restrict  __s1 ,
                                                       wchar_t const   * __restrict  __s2 ,
                                                       size_t __n ) ;
__inline extern  __attribute__((__nothrow__)) wint_t btowc(int __c ) ;
__inline extern  __attribute__((__nothrow__)) int wctob(wint_t __wc ) ;
extern  __attribute__((__nothrow__)) int mbsinit(mbstate_t const   *__ps )  __attribute__((__pure__)) ;
extern  __attribute__((__nothrow__)) size_t mbrtowc(wchar_t * __restrict  __pwc ,
                                                    char const   * __restrict  __s ,
                                                    size_t __n , mbstate_t *__p ) ;
extern  __attribute__((__nothrow__)) size_t wcrtomb(char * __restrict  __s ,
                                                    wchar_t __wc ,
                                                    mbstate_t * __restrict  __ps ) ;
extern  __attribute__((__nothrow__)) size_t __mbrlen(char const   * __restrict  __s ,
                                                     size_t __n ,
                                                     mbstate_t * __restrict  __ps ) ;
__inline extern  __attribute__((__nothrow__)) size_t mbrlen(char const   * __restrict  __s ,
                                                            size_t __n ,
                                                            mbstate_t * __restrict  __ps ) ;
extern wint_t __btowc_alias(int __c )  __asm__("btowc")  ;
__inline extern  __attribute__((__nothrow__)) wint_t btowc(int __c ) ;
__inline extern wint_t btowc(int __c ) 
{ wint_t tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1136] == 0) {
    {
    fprintf(_coverage_fout, "1136\n");
    fflush(_coverage_fout);
    ___coverage_array[1136] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __btowc_alias(__c);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1137] == 0) {
    {
    fprintf(_coverage_fout, "1137\n");
    fflush(_coverage_fout);
    ___coverage_array[1137] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern int __wctob_alias(wint_t __c )  __asm__("wctob")  ;
__inline extern  __attribute__((__nothrow__)) int wctob(wint_t __wc ) ;
__inline extern int wctob(wint_t __wc ) 
{ int tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1138] == 0) {
    {
    fprintf(_coverage_fout, "1138\n");
    fflush(_coverage_fout);
    ___coverage_array[1138] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __wctob_alias(__wc);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1139] == 0) {
    {
    fprintf(_coverage_fout, "1139\n");
    fflush(_coverage_fout);
    ___coverage_array[1139] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) size_t mbrlen(char const   * __restrict  __s ,
                                                            size_t __n ,
                                                            mbstate_t * __restrict  __ps ) ;
__inline extern size_t mbrlen(char const   * __restrict  __s , size_t __n ,
                              mbstate_t * __restrict  __ps ) 
{ size_t tmp ;
  size_t tmp___0 ;
  size_t tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1144] == 0) {
    {
    fprintf(_coverage_fout, "1144\n");
    fflush(_coverage_fout);
    ___coverage_array[1144] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )__ps != (unsigned int )((void *)0)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1140] == 0) {
      {
      fprintf(_coverage_fout, "1140\n");
      fflush(_coverage_fout);
      ___coverage_array[1140] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = mbrtowc((wchar_t */* __restrict  */)((void *)0), __s, __n,
                  (mbstate_t *)__ps);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1141] == 0) {
      {
      fprintf(_coverage_fout, "1141\n");
      fflush(_coverage_fout);
      ___coverage_array[1141] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = tmp;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1142] == 0) {
      {
      fprintf(_coverage_fout, "1142\n");
      fflush(_coverage_fout);
      ___coverage_array[1142] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = __mbrlen(__s, __n, (mbstate_t */* __restrict  */)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1143] == 0) {
      {
      fprintf(_coverage_fout, "1143\n");
      fflush(_coverage_fout);
      ___coverage_array[1143] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1145] == 0) {
    {
    fprintf(_coverage_fout, "1145\n");
    fflush(_coverage_fout);
    ___coverage_array[1145] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp___1);
}
}
extern  __attribute__((__nothrow__)) size_t mbsrtowcs(wchar_t * __restrict  __dst ,
                                                      char const   ** __restrict  __src ,
                                                      size_t __len ,
                                                      mbstate_t * __restrict  __ps ) ;
extern  __attribute__((__nothrow__)) size_t wcsrtombs(char * __restrict  __dst ,
                                                      wchar_t const   ** __restrict  __src ,
                                                      size_t __len ,
                                                      mbstate_t * __restrict  __ps ) ;
extern  __attribute__((__nothrow__)) size_t mbsnrtowcs(wchar_t * __restrict  __dst ,
                                                       char const   ** __restrict  __src ,
                                                       size_t __nmc ,
                                                       size_t __len ,
                                                       mbstate_t * __restrict  __ps ) ;
extern  __attribute__((__nothrow__)) size_t wcsnrtombs(char * __restrict  __dst ,
                                                       wchar_t const   ** __restrict  __src ,
                                                       size_t __nwc ,
                                                       size_t __len ,
                                                       mbstate_t * __restrict  __ps ) ;
extern  __attribute__((__nothrow__)) int wcwidth(wchar_t __c ) ;
extern  __attribute__((__nothrow__)) int wcswidth(wchar_t const   *__s ,
                                                  size_t __n ) ;
extern  __attribute__((__nothrow__)) double wcstod(wchar_t const   * __restrict  __nptr ,
                                                   wchar_t ** __restrict  __endptr ) ;
extern  __attribute__((__nothrow__)) float wcstof(wchar_t const   * __restrict  __nptr ,
                                                  wchar_t ** __restrict  __endptr ) ;
extern  __attribute__((__nothrow__)) long double wcstold(wchar_t const   * __restrict  __nptr ,
                                                         wchar_t ** __restrict  __endptr ) ;
extern  __attribute__((__nothrow__)) long wcstol(wchar_t const   * __restrict  __nptr ,
                                                 wchar_t ** __restrict  __endptr ,
                                                 int __base ) ;
extern  __attribute__((__nothrow__)) unsigned long wcstoul(wchar_t const   * __restrict  __nptr ,
                                                           wchar_t ** __restrict  __endptr ,
                                                           int __base ) ;
extern  __attribute__((__nothrow__)) long long wcstoll(wchar_t const   * __restrict  __nptr ,
                                                       wchar_t ** __restrict  __endptr ,
                                                       int __base ) ;
extern  __attribute__((__nothrow__)) unsigned long long wcstoull(wchar_t const   * __restrict  __nptr ,
                                                                 wchar_t ** __restrict  __endptr ,
                                                                 int __base ) ;
extern  __attribute__((__nothrow__)) long long wcstoq(wchar_t const   * __restrict  __nptr ,
                                                      wchar_t ** __restrict  __endptr ,
                                                      int __base ) ;
extern  __attribute__((__nothrow__)) unsigned long long wcstouq(wchar_t const   * __restrict  __nptr ,
                                                                wchar_t ** __restrict  __endptr ,
                                                                int __base ) ;
extern  __attribute__((__nothrow__)) long wcstol_l(wchar_t const   * __restrict  __nptr ,
                                                   wchar_t ** __restrict  __endptr ,
                                                   int __base ,
                                                   __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) unsigned long wcstoul_l(wchar_t const   * __restrict  __nptr ,
                                                             wchar_t ** __restrict  __endptr ,
                                                             int __base ,
                                                             __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) long long wcstoll_l(wchar_t const   * __restrict  __nptr ,
                                                         wchar_t ** __restrict  __endptr ,
                                                         int __base ,
                                                         __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) unsigned long long wcstoull_l(wchar_t const   * __restrict  __nptr ,
                                                                   wchar_t ** __restrict  __endptr ,
                                                                   int __base ,
                                                                   __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) double wcstod_l(wchar_t const   * __restrict  __nptr ,
                                                     wchar_t ** __restrict  __endptr ,
                                                     __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) float wcstof_l(wchar_t const   * __restrict  __nptr ,
                                                    wchar_t ** __restrict  __endptr ,
                                                    __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) long double wcstold_l(wchar_t const   * __restrict  __nptr ,
                                                           wchar_t ** __restrict  __endptr ,
                                                           __locale_t __loc ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcpcpy(wchar_t * __restrict  __dest ,
                                                     wchar_t const   * __restrict  __src ) ;
extern  __attribute__((__nothrow__)) wchar_t *wcpncpy(wchar_t * __restrict  __dest ,
                                                      wchar_t const   * __restrict  __src ,
                                                      size_t __n ) ;
extern  __attribute__((__nothrow__)) __FILE *open_wmemstream(wchar_t **__bufloc ,
                                                             size_t *__sizeloc ) ;
extern  __attribute__((__nothrow__)) int fwide(__FILE *__fp , int __mode ) ;
extern int fwprintf(__FILE * __restrict  __stream ,
                    wchar_t const   * __restrict  __format  , ...) ;
extern int wprintf(wchar_t const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) int swprintf(wchar_t * __restrict  __s ,
                                                  size_t __n ,
                                                  wchar_t const   * __restrict  __format 
                                                  , ...) ;
extern int vfwprintf(__FILE * __restrict  __s ,
                     wchar_t const   * __restrict  __format ,
                     __gnuc_va_list __arg ) ;
extern int vwprintf(wchar_t const   * __restrict  __format ,
                    __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int vswprintf(wchar_t * __restrict  __s ,
                                                   size_t __n ,
                                                   wchar_t const   * __restrict  __format ,
                                                   __gnuc_va_list __arg ) ;
extern int fwscanf(__FILE * __restrict  __stream ,
                   wchar_t const   * __restrict  __format  , ...) ;
extern int wscanf(wchar_t const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) int swscanf(wchar_t const   * __restrict  __s ,
                                                 wchar_t const   * __restrict  __format 
                                                 , ...) ;
extern int vfwscanf(__FILE * __restrict  __s ,
                    wchar_t const   * __restrict  __format ,
                    __gnuc_va_list __arg ) ;
extern int vwscanf(wchar_t const   * __restrict  __format ,
                   __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int vswscanf(wchar_t const   * __restrict  __s ,
                                                  wchar_t const   * __restrict  __format ,
                                                  __gnuc_va_list __arg ) ;
extern wint_t fgetwc(__FILE *__stream ) ;
extern wint_t getwc(__FILE *__stream ) ;
extern wint_t getwchar(void) ;
extern wint_t fputwc(wchar_t __wc , __FILE *__stream ) ;
extern wint_t putwc(wchar_t __wc , __FILE *__stream ) ;
extern wint_t putwchar(wchar_t __wc ) ;
extern wchar_t *fgetws(wchar_t * __restrict  __ws , int __n ,
                       __FILE * __restrict  __stream ) ;
extern int fputws(wchar_t const   * __restrict  __ws ,
                  __FILE * __restrict  __stream ) ;
extern wint_t ungetwc(wint_t __wc , __FILE *__stream ) ;
extern wint_t getwc_unlocked(__FILE *__stream ) ;
extern wint_t getwchar_unlocked(void) ;
extern wint_t fgetwc_unlocked(__FILE *__stream ) ;
extern wint_t fputwc_unlocked(wchar_t __wc , __FILE *__stream ) ;
extern wint_t putwc_unlocked(wchar_t __wc , __FILE *__stream ) ;
extern wint_t putwchar_unlocked(wchar_t __wc ) ;
extern wchar_t *fgetws_unlocked(wchar_t * __restrict  __ws , int __n ,
                                __FILE * __restrict  __stream ) ;
extern int fputws_unlocked(wchar_t const   * __restrict  __ws ,
                           __FILE * __restrict  __stream ) ;
extern  __attribute__((__nothrow__)) size_t wcsftime(wchar_t * __restrict  __s ,
                                                     size_t __maxsize ,
                                                     wchar_t const   * __restrict  __format ,
                                                     struct tm  const  * __restrict  __tp ) ;
extern  __attribute__((__nothrow__)) size_t wcsftime_l(wchar_t * __restrict  __s ,
                                                       size_t __maxsize ,
                                                       wchar_t const   * __restrict  __format ,
                                                       struct tm  const  * __restrict  __tp ,
                                                       __locale_t __loc ) ;
extern int zm_activate_filestat(int type , int module_number ) ;
extern int zm_deactivate_filestat(int type , int module_number ) ;
extern void zif_realpath_cache_size(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zif_realpath_cache_get(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_clearstatcache(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_fileatime(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_filectime(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_filegroup(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_fileinode(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_filemtime(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_fileowner(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_fileperms(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_filesize(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_filetype(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_is_writable(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void zif_is_readable(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void zif_is_executable(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_is_file(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_is_dir(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_is_link(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_file_exists(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void php_if_stat(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void php_if_lstat(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_disk_total_space(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_disk_free_space(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
extern void zif_chown(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_chgrp(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_lchown(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_lchgrp(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_chmod(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_touch(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  php_clear_stat_cache(zend_bool clear_realpath_cache ,
                                                                             char const   *filename ,
                                                                             int filename_len ) ;
extern void __attribute__((__visibility__("default")))  php_stat(char const   *filename ,
                                                                 php_stat_len filename_length ,
                                                                 int type ,
                                                                 zval *return_value ) ;
extern void __attribute__((__visibility__("default")))  zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini ) ;
extern void __attribute__((__visibility__("default")))  zend_strip(void) ;
extern int __attribute__((__visibility__("default")))  highlight_file(char *filename ,
                                                                      zend_syntax_highlighter_ini *syntax_highlighter_ini ) ;
extern int __attribute__((__visibility__("default")))  highlight_string(zval *str ,
                                                                        zend_syntax_highlighter_ini *syntax_highlighter_ini ,
                                                                        char *str_name ) ;
extern void __attribute__((__visibility__("default")))  zend_html_putc(char c ) ;
extern void __attribute__((__visibility__("default")))  zend_html_puts(char const   *s ,
                                                                       uint len ) ;
extern zend_syntax_highlighter_ini syntax_highlighter_ini ;
extern int zm_startup_url_scanner_ex(int type , int module_number ) ;
extern int zm_shutdown_url_scanner_ex(int type , int module_number ) ;
extern int zm_activate_url_scanner_ex(int type , int module_number ) ;
extern int zm_deactivate_url_scanner_ex(int type , int module_number ) ;
extern char __attribute__((__visibility__("default")))  *php_url_scanner_adapt_single_url(char const   *url ,
                                                                                          size_t urllen ,
                                                                                          char const   *name ,
                                                                                          char const   *value ,
                                                                                          size_t *newlen ) ;
extern int __attribute__((__visibility__("default")))  php_url_scanner_add_var(char *name ,
                                                                               int name_len ,
                                                                               char *value ,
                                                                               int value_len ,
                                                                               int urlencode ) ;
extern int __attribute__((__visibility__("default")))  php_url_scanner_reset_vars(void) ;
extern zend_module_entry basic_functions_module ;
extern int zm_startup_basic(int type , int module_number ) ;
extern int zm_shutdown_basic(int type , int module_number ) ;
extern int zm_activate_basic(int type , int module_number ) ;
extern int zm_deactivate_basic(int type , int module_number ) ;
extern void zm_info_basic(zend_module_entry *zend_module ) ;
extern void zif_constant(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_sleep(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_usleep(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_time_nanosleep(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_time_sleep_until(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_flush(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void php_inet_ntop(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void php_inet_pton(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_ip2long(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_long2ip(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_getenv(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_putenv(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_getopt(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_get_current_user(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_set_time_limit(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_header_register_callback(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) ;
extern void zif_get_cfg_var(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void zif_set_magic_quotes_runtime(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) ;
extern void zif_get_magic_quotes_runtime(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) ;
extern void zif_get_magic_quotes_gpc(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void zif_error_log(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_error_get_last(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_call_user_func(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_call_user_func_array(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void zif_call_user_method(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_call_user_method_array(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_forward_static_call(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ) ;
extern void zif_forward_static_call_array(int ht , zval *return_value ,
                                          zval **return_value_ptr ,
                                          zval *this_ptr ,
                                          int return_value_used ) ;
extern void zif_register_shutdown_function(int ht , zval *return_value ,
                                           zval **return_value_ptr ,
                                           zval *this_ptr ,
                                           int return_value_used ) ;
extern void zif_highlight_file(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_highlight_string(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_php_strip_whitespace(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  php_get_highlight_struct(zend_syntax_highlighter_ini *syntax_highlighter_ini ) ;
extern void zif_ini_get(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_ini_get_all(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void zif_ini_set(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_ini_restore(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void zif_get_include_path(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_set_include_path(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_restore_include_path(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void zif_print_r(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_fprintf(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_vfprintf(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_connection_aborted(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_connection_status(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void zif_ignore_user_abort(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern void zif_getservbyname(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_getservbyport(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_getprotobyname(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_getprotobynumber(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void php_if_crc32(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_register_tick_function(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_unregister_tick_function(int ht , zval *return_value ,
                                         zval **return_value_ptr ,
                                         zval *this_ptr , int return_value_used ) ;
extern void zif_sys_getloadavg(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_is_uploaded_file(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_move_uploaded_file(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_parse_ini_file(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
extern void zif_parse_ini_string(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
extern void zif_str_rot13(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_stream_get_filters(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
extern void zif_stream_filter_register(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ) ;
extern void zif_stream_bucket_make_writeable(int ht , zval *return_value ,
                                             zval **return_value_ptr ,
                                             zval *this_ptr ,
                                             int return_value_used ) ;
extern void zif_stream_bucket_prepend(int ht , zval *return_value ,
                                      zval **return_value_ptr , zval *this_ptr ,
                                      int return_value_used ) ;
extern void zif_stream_bucket_append(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
extern void zif_stream_bucket_new(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
extern int zm_startup_user_filters(int type , int module_number ) ;
extern int zm_deactivate_user_filters(int type , int module_number ) ;
extern int __attribute__((__visibility__("default")))  _php_error_log(int opt_err ,
                                                                      char *message ,
                                                                      char *opt ,
                                                                      char *headers ) ;
extern int __attribute__((__visibility__("default")))  _php_error_log_ex(int opt_err ,
                                                                         char *message ,
                                                                         int message_len ,
                                                                         char *opt ,
                                                                         char *headers ) ;
extern int __attribute__((__visibility__("default")))  php_prefix_varname(zval *result ,
                                                                          zval *prefix ,
                                                                          char *var_name ,
                                                                          int var_name_len ,
                                                                          zend_bool add_underscore ) ;
extern php_basic_globals __attribute__((__visibility__("default")))  basic_globals ;
extern double __attribute__((__visibility__("default")))  php_get_nan(void) ;
extern double __attribute__((__visibility__("default")))  php_get_inf(void) ;
extern char __attribute__((__visibility__("default")))  *php_canonicalize_version(char const   * ) ;
extern int __attribute__((__visibility__("default")))  php_version_compare(char const   * ,
                                                                           char const   * ) ;
extern void zif_version_compare(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
extern char __attribute__((__visibility__("default")))  *_php_math_number_format(double  ,
                                                                                 int  ,
                                                                                 char  ,
                                                                                 char  ) ;
extern char __attribute__((__visibility__("default")))  *_php_math_number_format_ex(double  ,
                                                                                    int  ,
                                                                                    char * ,
                                                                                    size_t  ,
                                                                                    char * ,
                                                                                    size_t  ) ;
extern char __attribute__((__visibility__("default")))  *_php_math_longtobase(zval *arg ,
                                                                              int base ) ;
extern long __attribute__((__visibility__("default")))  _php_math_basetolong(zval *arg ,
                                                                             int base ) ;
extern int __attribute__((__visibility__("default")))  _php_math_basetozval(zval *arg ,
                                                                            int base ,
                                                                            zval *ret ) ;
extern char __attribute__((__visibility__("default")))  *_php_math_zvaltobase(zval *arg ,
                                                                              int base ) ;
extern void zif_sin(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_cos(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_tan(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_asin(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_acos(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_atan(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_atan2(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_pi(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
extern void zif_exp(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_log(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_log10(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_is_finite(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
extern void zif_is_infinite(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
extern void zif_is_nan(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_pow(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_sqrt(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_srand(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_rand(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_getrandmax(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
extern void zif_mt_srand(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
extern void zif_mt_rand(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_mt_getrandmax(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_abs(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
extern void zif_ceil(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_floor(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_round(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_decbin(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_dechex(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_decoct(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_bindec(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_hexdec(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_octdec(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
extern void zif_base_convert(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
extern void zif_number_format(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
extern void zif_fmod(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_deg2rad(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_rad2deg(int ht , zval *return_value , zval **return_value_ptr ,
                        zval *this_ptr , int return_value_used ) ;
extern void zif_hypot(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_expm1(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_log1p(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_sinh(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_cosh(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_tanh(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
extern void zif_asinh(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_acosh(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern void zif_atanh(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
extern  __attribute__((__nothrow__)) intmax_t imaxabs(intmax_t __n )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) imaxdiv_t imaxdiv(intmax_t __numer ,
                                                       intmax_t __denom )  __attribute__((__const__)) ;
__inline extern  __attribute__((__nothrow__)) intmax_t strtoimax(char const   * __restrict  nptr ,
                                                                 char ** __restrict  endptr ,
                                                                 int base ) ;
__inline extern  __attribute__((__nothrow__)) uintmax_t strtoumax(char const   * __restrict  nptr ,
                                                                  char ** __restrict  endptr ,
                                                                  int base ) ;
__inline extern  __attribute__((__nothrow__)) intmax_t wcstoimax(__gwchar_t const   * __restrict  nptr ,
                                                                 __gwchar_t ** __restrict  endptr ,
                                                                 int base ) ;
__inline extern  __attribute__((__nothrow__)) uintmax_t wcstoumax(__gwchar_t const   * __restrict  nptr ,
                                                                  __gwchar_t ** __restrict  endptr ,
                                                                  int base ) ;
extern  __attribute__((__nothrow__)) long long __strtoll_internal(char const   * __restrict  __nptr ,
                                                                  char ** __restrict  __endptr ,
                                                                  int __base ,
                                                                  int __group )  __attribute__((__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) intmax_t strtoimax(char const   * __restrict  nptr ,
                                                                 char ** __restrict  endptr ,
                                                                 int base ) ;
__inline extern intmax_t strtoimax(char const   * __restrict  nptr ,
                                   char ** __restrict  endptr , int base ) 
{ long long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1146] == 0) {
    {
    fprintf(_coverage_fout, "1146\n");
    fflush(_coverage_fout);
    ___coverage_array[1146] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __strtoll_internal(nptr, endptr, base, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1147] == 0) {
    {
    fprintf(_coverage_fout, "1147\n");
    fflush(_coverage_fout);
    ___coverage_array[1147] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern  __attribute__((__nothrow__)) unsigned long long __strtoull_internal(char const   * __restrict  __nptr ,
                                                                            char ** __restrict  __endptr ,
                                                                            int __base ,
                                                                            int __group )  __attribute__((__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) uintmax_t strtoumax(char const   * __restrict  nptr ,
                                                                  char ** __restrict  endptr ,
                                                                  int base ) ;
__inline extern uintmax_t strtoumax(char const   * __restrict  nptr ,
                                    char ** __restrict  endptr , int base ) 
{ unsigned long long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1148] == 0) {
    {
    fprintf(_coverage_fout, "1148\n");
    fflush(_coverage_fout);
    ___coverage_array[1148] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __strtoull_internal(nptr, endptr, base, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1149] == 0) {
    {
    fprintf(_coverage_fout, "1149\n");
    fflush(_coverage_fout);
    ___coverage_array[1149] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern  __attribute__((__nothrow__)) long long __wcstoll_internal(__gwchar_t const   * __restrict  __nptr ,
                                                                  __gwchar_t ** __restrict  __endptr ,
                                                                  int __base ,
                                                                  int __group )  __attribute__((__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) intmax_t wcstoimax(__gwchar_t const   * __restrict  nptr ,
                                                                 __gwchar_t ** __restrict  endptr ,
                                                                 int base ) ;
__inline extern intmax_t wcstoimax(__gwchar_t const   * __restrict  nptr ,
                                   __gwchar_t ** __restrict  endptr , int base ) 
{ long long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1150] == 0) {
    {
    fprintf(_coverage_fout, "1150\n");
    fflush(_coverage_fout);
    ___coverage_array[1150] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __wcstoll_internal(nptr, endptr, base, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1151] == 0) {
    {
    fprintf(_coverage_fout, "1151\n");
    fflush(_coverage_fout);
    ___coverage_array[1151] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern  __attribute__((__nothrow__)) unsigned long long __wcstoull_internal(__gwchar_t const   * __restrict  __nptr ,
                                                                            __gwchar_t ** __restrict  __endptr ,
                                                                            int __base ,
                                                                            int __group )  __attribute__((__nonnull__(1))) ;
__inline extern  __attribute__((__nothrow__)) uintmax_t wcstoumax(__gwchar_t const   * __restrict  nptr ,
                                                                  __gwchar_t ** __restrict  endptr ,
                                                                  int base ) ;
__inline extern uintmax_t wcstoumax(__gwchar_t const   * __restrict  nptr ,
                                    __gwchar_t ** __restrict  endptr , int base ) 
{ unsigned long long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1152] == 0) {
    {
    fprintf(_coverage_fout, "1152\n");
    fflush(_coverage_fout);
    ___coverage_array[1152] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = __wcstoull_internal(nptr, endptr, base, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1153] == 0) {
    {
    fprintf(_coverage_fout, "1153\n");
    fflush(_coverage_fout);
    ___coverage_array[1153] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
extern timelib_sll timelib_day_of_week(timelib_sll y , timelib_sll m ,
                                       timelib_sll d ) ;
extern timelib_sll timelib_iso_day_of_week(timelib_sll y , timelib_sll m ,
                                           timelib_sll d ) ;
extern timelib_sll timelib_day_of_year(timelib_sll y , timelib_sll m ,
                                       timelib_sll d ) ;
extern timelib_sll timelib_daynr_from_weeknr(timelib_sll y , timelib_sll w ,
                                             timelib_sll d ) ;
extern timelib_sll timelib_days_in_month(timelib_sll y , timelib_sll m ) ;
extern void timelib_isoweek_from_date(timelib_sll y , timelib_sll m ,
                                      timelib_sll d , timelib_sll *iw ,
                                      timelib_sll *iy ) ;
extern int timelib_valid_time(timelib_sll h , timelib_sll i , timelib_sll s ) ;
extern int timelib_valid_date(timelib_sll y , timelib_sll m , timelib_sll d ) ;
extern timelib_time *timelib_strtotime(char *s , int len ,
                                       timelib_error_container **errors ,
                                       timelib_tzdb const   *tzdb ) ;
extern timelib_time *timelib_parse_from_format(char *format , char *s ,
                                               int len ,
                                               timelib_error_container **errors ,
                                               timelib_tzdb const   *tzdb ) ;
extern void timelib_fill_holes(timelib_time *parsed , timelib_time *now ,
                               int options ) ;
extern char *timelib_timezone_id_from_abbr(char const   *abbr , long gmtoffset ,
                                           int isdst ) ;
extern timelib_tz_lookup_table const   *timelib_timezone_abbreviations_list(void) ;
extern void timelib_strtointerval(char *s , int len , timelib_time **begin ,
                                  timelib_time **end ,
                                  timelib_rel_time **period , int *recurrences ,
                                  struct timelib_error_container **errors ) ;
extern void timelib_update_ts(timelib_time *time , timelib_tzinfo *tzi ) ;
extern void timelib_do_rel_normalize(timelib_time *base , timelib_rel_time *rt ) ;
extern int timelib_apply_localtime(timelib_time *t , unsigned int localtime ) ;
extern void timelib_unixtime2gmt(timelib_time *tm , timelib_sll ts ) ;
extern void timelib_unixtime2local(timelib_time *tm , timelib_sll ts ) ;
extern void timelib_update_from_sse(timelib_time *tm ) ;
extern void timelib_set_timezone(timelib_time *t , timelib_tzinfo *tz ) ;
extern int timelib_timezone_id_is_valid(char *timezone ,
                                        timelib_tzdb const   *tzdb ) ;
extern timelib_tzinfo *timelib_parse_tzfile(char *timezone ,
                                            timelib_tzdb const   *tzdb ) ;
extern int timelib_timestamp_is_in_dst(timelib_sll ts , timelib_tzinfo *tz ) ;
extern timelib_time_offset *timelib_get_time_zone_info(timelib_sll ts ,
                                                       timelib_tzinfo *tz ) ;
extern timelib_sll timelib_get_current_offset(timelib_time *t ) ;
extern void timelib_dump_tzinfo(timelib_tzinfo *tz ) ;
extern timelib_tzdb const   *timelib_builtin_db(void) ;
extern timelib_tzdb_index_entry const   *timelib_timezone_builtin_identifiers_list(int *count ) ;
extern timelib_tzinfo *timelib_tzinfo_ctor(char *name ) ;
extern void timelib_time_tz_abbr_update(timelib_time *tm , char *tz_abbr ) ;
extern void timelib_time_tz_name_update(timelib_time *tm , char *tz_name ) ;
extern void timelib_tzinfo_dtor(timelib_tzinfo *tz ) ;
extern timelib_tzinfo *timelib_tzinfo_clone(timelib_tzinfo *tz ) ;
extern timelib_rel_time *timelib_rel_time_ctor(void) ;
extern void timelib_rel_time_dtor(timelib_rel_time *t ) ;
extern timelib_rel_time *timelib_rel_time_clone(timelib_rel_time *tz ) ;
extern timelib_time *timelib_time_ctor(void) ;
extern void timelib_time_set_option(timelib_time *tm , int option ,
                                    void *option_value ) ;
extern void timelib_time_dtor(timelib_time *t ) ;
extern timelib_time *timelib_time_clone(timelib_time *orig ) ;
extern timelib_time_offset *timelib_time_offset_ctor(void) ;
extern void timelib_time_offset_dtor(timelib_time_offset *t ) ;
extern void timelib_error_container_dtor(timelib_error_container *errors ) ;
extern long timelib_date_to_int(timelib_time *d , int *error ) ;
extern void timelib_dump_date(timelib_time *d , int options ) ;
extern void timelib_dump_rel_time(timelib_rel_time *d ) ;
extern void timelib_decimal_hour_to_hms(double h , int *hour , int *min ,
                                        int *sec ) ;
extern double timelib_ts_to_juliandate(timelib_sll ts ) ;
extern int timelib_astro_rise_set_altitude(timelib_time *time , double lon ,
                                           double lat , double altit ,
                                           int upper_limb , double *h_rise ,
                                           double *h_set ,
                                           timelib_sll *ts_rise ,
                                           timelib_sll *ts_set ,
                                           timelib_sll *ts_transit ) ;
extern timelib_rel_time *timelib_diff(timelib_time *one , timelib_time *two ) ;
zend_module_entry date_module_entry ;
void zif_date(int ht , zval *return_value , zval **return_value_ptr ,
              zval *this_ptr , int return_value_used ) ;
void zif_idate(int ht , zval *return_value , zval **return_value_ptr ,
               zval *this_ptr , int return_value_used ) ;
void zif_gmdate(int ht , zval *return_value , zval **return_value_ptr ,
                zval *this_ptr , int return_value_used ) ;
void zif_strtotime(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
void zif_mktime(int ht , zval *return_value , zval **return_value_ptr ,
                zval *this_ptr , int return_value_used ) ;
void zif_gmmktime(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) ;
void zif_checkdate(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
void zif_strftime(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) ;
void zif_gmstrftime(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
void zif_time(int ht , zval *return_value , zval **return_value_ptr ,
              zval *this_ptr , int return_value_used ) ;
void zif_localtime(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
void zif_getdate(int ht , zval *return_value , zval **return_value_ptr ,
                 zval *this_ptr , int return_value_used ) ;
void zim_DateTime___construct(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
void zim_DateTime___wakeup(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
void zim_DateTime___set_state(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
void zif_date_create(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
void zif_date_create_from_format(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
void zif_date_parse(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) ;
void zif_date_parse_from_format(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
void zif_date_get_last_errors(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
void zif_date_format(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
void zif_date_modify(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
void zif_date_add(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) ;
void zif_date_sub(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) ;
void zif_date_timezone_get(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
void zif_date_timezone_set(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
void zif_date_offset_get(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) ;
void zif_date_diff(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) ;
void zif_date_time_set(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
void zif_date_date_set(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
void zif_date_isodate_set(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) ;
void zif_date_timestamp_set(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
void zif_date_timestamp_get(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) ;
void zim_DateTimeZone___construct(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
void zif_timezone_open(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
void zif_timezone_name_get(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) ;
void zif_timezone_name_from_abbr(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) ;
void zif_timezone_offset_get(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) ;
void zif_timezone_transitions_get(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
void zif_timezone_location_get(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) ;
void zif_timezone_identifiers_list(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
void zif_timezone_abbreviations_list(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) ;
void zif_timezone_version_get(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
void zim_DateInterval___construct(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) ;
void zif_date_interval_format(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) ;
void zif_date_interval_create_from_date_string(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) ;
void zim_DatePeriod___construct(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) ;
void zif_date_default_timezone_set(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
void zif_date_default_timezone_get(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) ;
void zif_date_sunrise(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) ;
void zif_date_sunset(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) ;
void zif_date_sun_info(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) ;
int zm_activate_date(int type , int module_number ) ;
int zm_deactivate_date(int type , int module_number ) ;
int zm_startup_date(int type , int module_number ) ;
int zm_shutdown_date(int type , int module_number ) ;
void zm_info_date(zend_module_entry *zend_module ) ;
long __attribute__((__visibility__("default")))  php_parse_date(char *string ,
                                                                long *now ) ;
void __attribute__((__visibility__("default")))  php_mktime(int ht ,
                                                            zval *return_value ,
                                                            zval **return_value_ptr ,
                                                            zval *this_ptr ,
                                                            int return_value_used ,
                                                            int gmt ) ;
int __attribute__((__visibility__("default")))  php_idate(char format ,
                                                          time_t ts ,
                                                          int localtime___0 ) ;
void __attribute__((__visibility__("default")))  php_strftime(int ht ,
                                                              zval *return_value ,
                                                              zval **return_value_ptr ,
                                                              zval *this_ptr ,
                                                              int return_value_used ,
                                                              int gmt ) ;
char __attribute__((__visibility__("default")))  *php_format_date(char *format ,
                                                                  int format_len ,
                                                                  time_t ts ,
                                                                  int localtime___0 ) ;
void __attribute__((__visibility__("default")))  php_date_set_tzdb(timelib_tzdb *tzdb ) ;
timelib_tzinfo __attribute__((__visibility__("default")))  *get_timezone_info(void) ;
zend_class_entry __attribute__((__visibility__("default")))  *php_date_get_date_ce(void) ;
zend_class_entry __attribute__((__visibility__("default")))  *php_date_get_timezone_ce(void) ;
zval __attribute__((__visibility__("default")))  *php_date_instantiate(zend_class_entry *pce ,
                                                                       zval *object ) ;
int __attribute__((__visibility__("default")))  php_date_initialize(php_date_obj *dateobj ,
                                                                    char *time_str ,
                                                                    int time_str_len ,
                                                                    char *format ,
                                                                    zval *timezone_object ,
                                                                    int ctor ) ;
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 *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 ) ;
__inline static long long php_date_llabs(long long i ) 
{ long long tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1156] == 0) {
    {
    fprintf(_coverage_fout, "1156\n");
    fflush(_coverage_fout);
    ___coverage_array[1156] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (i >= 0LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1154] == 0) {
      {
      fprintf(_coverage_fout, "1154\n");
      fflush(_coverage_fout);
      ___coverage_array[1154] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = i;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1155] == 0) {
      {
      fprintf(_coverage_fout, "1155\n");
      fflush(_coverage_fout);
      ___coverage_array[1155] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = - i;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1157] == 0) {
    {
    fprintf(_coverage_fout, "1157\n");
    fflush(_coverage_fout);
    ___coverage_array[1157] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
static zend_arg_info const   arginfo_date[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gmdate[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_idate[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strtotime[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"now", sizeof("now") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_mktime[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hour", sizeof("hour") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"min", sizeof("min") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"sec", sizeof("sec") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mon", sizeof("mon") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gmmktime[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hour", sizeof("hour") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"min", sizeof("min") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"sec", sizeof("sec") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mon", sizeof("mon") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_checkdate[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"month", sizeof("month") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strftime[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gmstrftime[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_time[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_localtime[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"associative_array", sizeof("associative_array") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_getdate[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp", sizeof("timestamp") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_default_timezone_set[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timezone_identifier", sizeof("timezone_identifier") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_date_default_timezone_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_sunrise[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"latitude", sizeof("latitude") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"longitude", sizeof("longitude") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"zenith", sizeof("zenith") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"gmt_offset", sizeof("gmt_offset") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_sunset[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"latitude", sizeof("latitude") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"longitude", sizeof("longitude") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"zenith", sizeof("zenith") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"gmt_offset", sizeof("gmt_offset") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_sun_info[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"latitude", sizeof("latitude") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"longitude", sizeof("longitude") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_create[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_create_from_format[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_parse[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"date", sizeof("date") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_parse_from_format[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"date", sizeof("date") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_get_last_errors[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_format[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_format[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_modify[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"modify", sizeof("modify") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_modify[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"modify", sizeof("modify") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_add[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"interval", sizeof("interval") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_add[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"interval", sizeof("interval") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_sub[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"interval", sizeof("interval") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_sub[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"interval", sizeof("interval") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_timezone_get[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_timezone_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_timezone_set[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timezone", sizeof("timezone") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_timezone_set[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timezone", sizeof("timezone") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_offset_get[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_offset_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_diff[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object2", sizeof("object2") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"absolute", sizeof("absolute") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_diff[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"absolute", sizeof("absolute") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_time_set[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hour", sizeof("hour") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"minute", sizeof("minute") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"second", sizeof("second") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_time_set[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hour", sizeof("hour") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"minute", sizeof("minute") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"second", sizeof("second") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_date_set[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )4, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"month", sizeof("month") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_date_set[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"month", sizeof("month") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_isodate_set[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"week", sizeof("week") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_isodate_set[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"year", sizeof("year") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"week", sizeof("week") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"day", sizeof("day") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_timestamp_set[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"unixtimestamp", sizeof("unixtimestamp") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_timestamp_set[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"unixtimestamp", sizeof("unixtimestamp") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_date_timestamp_get[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_timestamp_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_open[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timezone", sizeof("timezone") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_name_get[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_method_name_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_name_from_abbr[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"abbr", sizeof("abbr") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"gmtoffset", sizeof("gmtoffset") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"isdst", sizeof("isdst") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_offset_get[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"datetime", sizeof("datetime") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_method_offset_get[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"datetime", sizeof("datetime") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_transitions_get[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp_begin", sizeof("timestamp_begin") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}, 
        {"timestamp_end", sizeof("timestamp_end") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_method_transitions_get[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timestamp_begin", sizeof("timestamp_begin") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}, 
        {"timestamp_end", sizeof("timestamp_end") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_location_get[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_method_location_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_identifiers_list[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"what", sizeof("what") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"country", sizeof("country") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_abbreviations_list[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_timezone_version_get[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_interval_create_from_date_string[2]  = {      {(char const   *)((void *)0),
      (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0,
      (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_interval_format[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"object", sizeof("object") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_method_interval_format[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"format", sizeof("format") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_period_construct[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"start", sizeof("start") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"interval", sizeof("interval") - 1U, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"end", sizeof("end") - 1U, (char const   *)((void *)0), (zend_uint )0,
      (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_date_interval_construct[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0),
      (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"interval_spec", sizeof("interval_spec") - 1U,
      (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0,
      (zend_bool )0}};
zend_function_entry const   date_functions[47]  = 
  {      {"strtotime", & zif_strtotime, arginfo_strtotime,
      sizeof(arginfo_strtotime) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date", & zif_date, arginfo_date,
      sizeof(arginfo_date) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"idate", & zif_idate, arginfo_idate,
      sizeof(arginfo_idate) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gmdate",
      & zif_gmdate, arginfo_gmdate,
      sizeof(arginfo_gmdate) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"mktime", & zif_mktime, arginfo_mktime,
      sizeof(arginfo_mktime) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"gmmktime", & zif_gmmktime, arginfo_gmmktime,
      sizeof(arginfo_gmmktime) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"checkdate", & zif_checkdate, arginfo_checkdate,
      sizeof(arginfo_checkdate) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"strftime", & zif_strftime, arginfo_strftime,
      sizeof(arginfo_strftime) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"gmstrftime", & zif_gmstrftime, arginfo_gmstrftime,
      sizeof(arginfo_gmstrftime) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"time", & zif_time, arginfo_time,
      sizeof(arginfo_time) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"localtime", & zif_localtime, arginfo_localtime,
      sizeof(arginfo_localtime) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getdate", & zif_getdate, arginfo_getdate,
      sizeof(arginfo_getdate) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_create", & zif_date_create, arginfo_date_create,
      sizeof(arginfo_date_create) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_create_from_format", & zif_date_create_from_format,
      arginfo_date_create_from_format,
      sizeof(arginfo_date_create_from_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_parse", & zif_date_parse, arginfo_date_parse,
      sizeof(arginfo_date_parse) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_parse_from_format", & zif_date_parse_from_format,
      arginfo_date_parse_from_format,
      sizeof(arginfo_date_parse_from_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_get_last_errors", & zif_date_get_last_errors,
      arginfo_date_get_last_errors,
      sizeof(arginfo_date_get_last_errors) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_format", & zif_date_format, arginfo_date_format,
      sizeof(arginfo_date_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_modify", & zif_date_modify, arginfo_date_modify,
      sizeof(arginfo_date_modify) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_add", & zif_date_add, arginfo_date_add,
      sizeof(arginfo_date_add) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_sub", & zif_date_sub, arginfo_date_sub,
      sizeof(arginfo_date_sub) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_timezone_get", & zif_date_timezone_get, arginfo_date_timezone_get,
      sizeof(arginfo_date_timezone_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_timezone_set", & zif_date_timezone_set, arginfo_date_timezone_set,
      sizeof(arginfo_date_timezone_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_offset_get", & zif_date_offset_get, arginfo_date_offset_get,
      sizeof(arginfo_date_offset_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_diff", & zif_date_diff, arginfo_date_diff,
      sizeof(arginfo_date_diff) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_time_set", & zif_date_time_set, arginfo_date_time_set,
      sizeof(arginfo_date_time_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_date_set", & zif_date_date_set, arginfo_date_date_set,
      sizeof(arginfo_date_date_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_isodate_set", & zif_date_isodate_set, arginfo_date_isodate_set,
      sizeof(arginfo_date_isodate_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_timestamp_set", & zif_date_timestamp_set,
      arginfo_date_timestamp_set,
      sizeof(arginfo_date_timestamp_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_timestamp_get", & zif_date_timestamp_get,
      arginfo_date_timestamp_get,
      sizeof(arginfo_date_timestamp_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_open", & zif_timezone_open, arginfo_timezone_open,
      sizeof(arginfo_timezone_open) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_name_get", & zif_timezone_name_get, arginfo_timezone_name_get,
      sizeof(arginfo_timezone_name_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_name_from_abbr", & zif_timezone_name_from_abbr,
      arginfo_timezone_name_from_abbr,
      sizeof(arginfo_timezone_name_from_abbr) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_offset_get", & zif_timezone_offset_get,
      arginfo_timezone_offset_get,
      sizeof(arginfo_timezone_offset_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_transitions_get", & zif_timezone_transitions_get,
      arginfo_timezone_transitions_get,
      sizeof(arginfo_timezone_transitions_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_location_get", & zif_timezone_location_get,
      arginfo_timezone_location_get,
      sizeof(arginfo_timezone_location_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_identifiers_list", & zif_timezone_identifiers_list,
      arginfo_timezone_identifiers_list,
      sizeof(arginfo_timezone_identifiers_list) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_abbreviations_list", & zif_timezone_abbreviations_list,
      arginfo_timezone_abbreviations_list,
      sizeof(arginfo_timezone_abbreviations_list) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"timezone_version_get", & zif_timezone_version_get,
      arginfo_timezone_version_get,
      sizeof(arginfo_timezone_version_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_interval_create_from_date_string",
      & zif_date_interval_create_from_date_string,
      arginfo_date_interval_create_from_date_string,
      sizeof(arginfo_date_interval_create_from_date_string) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_interval_format", & zif_date_interval_format,
      arginfo_date_interval_format,
      sizeof(arginfo_date_interval_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_default_timezone_set", & zif_date_default_timezone_set,
      arginfo_date_default_timezone_set,
      sizeof(arginfo_date_default_timezone_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_default_timezone_get", & zif_date_default_timezone_get,
      arginfo_date_default_timezone_get,
      sizeof(arginfo_date_default_timezone_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_sunrise", & zif_date_sunrise, arginfo_date_sunrise,
      sizeof(arginfo_date_sunrise) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_sunset", & zif_date_sunset, arginfo_date_sunset,
      sizeof(arginfo_date_sunset) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"date_sun_info", & zif_date_sun_info, arginfo_date_sun_info,
      sizeof(arginfo_date_sun_info) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {(char const   *)((void *)0),
      (void (*)(int ht , zval *return_value ,
                zval **return_value_ptr , zval *this_ptr ,
                int return_value_used ))((void *)0),
      (struct _zend_arg_info  const  *)((void *)0), 0U, 0U}};
zend_function_entry const   date_funcs_date[19]  = 
  {      {"__construct", & zim_DateTime___construct, arginfo_date_create,
      sizeof(arginfo_date_create) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )8448}, 
        {"__wakeup", & zim_DateTime___wakeup,
      (struct _zend_arg_info  const  *)((void *)0),
      sizeof((void *)0) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0x100}, 
        {"__set_state",
      & zim_DateTime___set_state, (struct _zend_arg_info  const  *)((void *)0),
      sizeof((void *)0) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )257}, 
        {"createFromFormat", & zif_date_create_from_format,
      arginfo_date_create_from_format,
      sizeof(arginfo_date_create_from_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )257}, 
        {"getLastErrors", & zif_date_get_last_errors, arginfo_date_get_last_errors,
      sizeof(arginfo_date_get_last_errors) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )257}, 
        {"format", & zif_date_format, arginfo_date_method_format,
      sizeof(arginfo_date_method_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"modify", & zif_date_modify, arginfo_date_method_modify,
      sizeof(arginfo_date_method_modify) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"add", & zif_date_add, arginfo_date_method_add,
      sizeof(arginfo_date_method_add) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"sub", & zif_date_sub, arginfo_date_method_sub,
      sizeof(arginfo_date_method_sub) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getTimezone", & zif_date_timezone_get, arginfo_date_method_timezone_get,
      sizeof(arginfo_date_method_timezone_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"setTimezone", & zif_date_timezone_set, arginfo_date_method_timezone_set,
      sizeof(arginfo_date_method_timezone_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getOffset", & zif_date_offset_get, arginfo_date_method_offset_get,
      sizeof(arginfo_date_method_offset_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"setTime", & zif_date_time_set, arginfo_date_method_time_set,
      sizeof(arginfo_date_method_time_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"setDate", & zif_date_date_set, arginfo_date_method_date_set,
      sizeof(arginfo_date_method_date_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"setISODate", & zif_date_isodate_set, arginfo_date_method_isodate_set,
      sizeof(arginfo_date_method_isodate_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"setTimestamp", & zif_date_timestamp_set,
      arginfo_date_method_timestamp_set,
      sizeof(arginfo_date_method_timestamp_set) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getTimestamp", & zif_date_timestamp_get,
      arginfo_date_method_timestamp_get,
      sizeof(arginfo_date_method_timestamp_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"diff", & zif_date_diff, arginfo_date_method_diff,
      sizeof(arginfo_date_method_diff) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {(char const   *)((void *)0),
      (void (*)(int ht , zval *return_value ,
                zval **return_value_ptr , zval *this_ptr ,
                int return_value_used ))((void *)0),
      (struct _zend_arg_info  const  *)((void *)0), 0U, 0U}};
zend_function_entry const   date_funcs_timezone[8]  = 
  {      {"__construct", & zim_DateTimeZone___construct, arginfo_timezone_open,
      sizeof(arginfo_timezone_open) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )8448}, 
        {"getName", & zif_timezone_name_get, arginfo_timezone_method_name_get,
      sizeof(arginfo_timezone_method_name_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getOffset", & zif_timezone_offset_get,
      arginfo_timezone_method_offset_get,
      sizeof(arginfo_timezone_method_offset_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getTransitions", & zif_timezone_transitions_get,
      arginfo_timezone_method_transitions_get,
      sizeof(arginfo_timezone_method_transitions_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"getLocation", & zif_timezone_location_get,
      arginfo_timezone_method_location_get,
      sizeof(arginfo_timezone_method_location_get) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"listAbbreviations", & zif_timezone_abbreviations_list,
      arginfo_timezone_abbreviations_list,
      sizeof(arginfo_timezone_abbreviations_list) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )257}, 
        {"listIdentifiers", & zif_timezone_identifiers_list,
      arginfo_timezone_identifiers_list,
      sizeof(arginfo_timezone_identifiers_list) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )257}, 
        {(char const   *)((void *)0),
      (void (*)(int ht , zval *return_value ,
                zval **return_value_ptr , zval *this_ptr ,
                int return_value_used ))((void *)0),
      (struct _zend_arg_info  const  *)((void *)0), 0U, 0U}};
zend_function_entry const   date_funcs_interval[4]  = {      {"__construct", & zim_DateInterval___construct,
      arginfo_date_interval_construct,
      sizeof(arginfo_date_interval_construct) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )8448}, 
        {"format", & zif_date_interval_format, arginfo_date_method_interval_format,
      sizeof(arginfo_date_method_interval_format) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )0}, 
        {"createFromDateString", & zif_date_interval_create_from_date_string,
      arginfo_date_interval_create_from_date_string,
      sizeof(arginfo_date_interval_create_from_date_string) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )257}, 
        {(char const   *)((void *)0),
      (void (*)(int ht , zval *return_value ,
                zval **return_value_ptr , zval *this_ptr ,
                int return_value_used ))((void *)0),
      (struct _zend_arg_info  const  *)((void *)0), 0U, 0U}};
zend_function_entry const   date_funcs_period[2]  = {      {"__construct", & zim_DatePeriod___construct,
      arginfo_date_period_construct,
      sizeof(arginfo_date_period_construct) / sizeof(struct _zend_arg_info ) - 1U,
      (zend_uint )8448}, 
        {(char const   *)((void *)0),
      (void (*)(int ht , zval *return_value ,
                zval **return_value_ptr , zval *this_ptr ,
                int return_value_used ))((void *)0),
      (struct _zend_arg_info  const  *)((void *)0), 0U, 0U}};
static char *guess_timezone(timelib_tzdb const   *tzdb ) ;
static void date_register_classes(void) ;
zend_date_globals date_globals  ;
static void zm_globals_ctor_date(zend_date_globals *date_globals___0 ) ;
timelib_tzdb *php_date_global_timezone_db  ;
int php_date_global_timezone_db_enabled  ;
static zend_ini_entry const   ini_entries[6]  = {      {0, (1 | (1 << 1)) | (1 << 2), (char *)"date.timezone",
      sizeof("date.timezone"),
      (int (*)(zend_ini_entry *entry , char *new_value , uint new_value_length ,
               void *mh_arg1 , void *mh_arg2 , void *mh_arg3 , int stage ))(& OnUpdateString),
      (void *)((long )((char *)(& ((zend_date_globals *)((void *)0))->default_timezone) - (char *)((void *)0))),
      (void *)(& date_globals), (void *)0, (char *)"", sizeof("") - 1U,
      (char *)((void *)0), (uint )0, 0, 0,
      (void (*)(zend_ini_entry *ini_entry , int type ))((void *)0)}, 
        {0, (1 | (1 << 1)) | (1 << 2), (char *)"date.default_latitude",
      sizeof("date.default_latitude"),
      (int (*)(zend_ini_entry *entry , char *new_value , uint new_value_length ,
               void *mh_arg1 , void *mh_arg2 , void *mh_arg3 , int stage ))((void *)0),
      (void *)0, (void *)0, (void *)0, (char *)"31.7667",
      sizeof("31.7667") - 1U, (char *)((void *)0), (uint )0, 0, 0,
      (void (*)(zend_ini_entry *ini_entry , int type ))((void *)0)}, 
        {0, (1 | (1 << 1)) | (1 << 2), (char *)"date.default_longitude",
      sizeof("date.default_longitude"),
      (int (*)(zend_ini_entry *entry , char *new_value , uint new_value_length ,
               void *mh_arg1 , void *mh_arg2 , void *mh_arg3 , int stage ))((void *)0),
      (void *)0, (void *)0, (void *)0, (char *)"35.2333",
      sizeof("35.2333") - 1U, (char *)((void *)0), (uint )0, 0, 0,
      (void (*)(zend_ini_entry *ini_entry , int type ))((void *)0)}, 
        {0, (1 | (1 << 1)) | (1 << 2), (char *)"date.sunset_zenith",
      sizeof("date.sunset_zenith"),
      (int (*)(zend_ini_entry *entry , char *new_value , uint new_value_length ,
               void *mh_arg1 , void *mh_arg2 , void *mh_arg3 , int stage ))((void *)0),
      (void *)0, (void *)0, (void *)0, (char *)"90.583333",
      sizeof("90.583333") - 1U, (char *)((void *)0), (uint )0, 0, 0,
      (void (*)(zend_ini_entry *ini_entry , int type ))((void *)0)}, 
        {0, (1 | (1 << 1)) | (1 << 2), (char *)"date.sunrise_zenith",
      sizeof("date.sunrise_zenith"),
      (int (*)(zend_ini_entry *entry , char *new_value , uint new_value_length ,
               void *mh_arg1 , void *mh_arg2 , void *mh_arg3 , int stage ))((void *)0),
      (void *)0, (void *)0, (void *)0, (char *)"90.583333",
      sizeof("90.583333") - 1U, (char *)((void *)0), (uint )0, 0, 0,
      (void (*)(zend_ini_entry *ini_entry , int type ))((void *)0)}, 
        {0, 0, (char *)((void *)0), (uint )0,
      (int (*)(zend_ini_entry *entry , char *new_value , uint new_value_length ,
               void *mh_arg1 , void *mh_arg2 , void *mh_arg3 , int stage ))((void *)0),
      (void *)0, (void *)0, (void *)0, (char *)((void *)0), (uint )0,
      (char *)((void *)0), (uint )0, 0, 0,
      (void (*)(zend_ini_entry *ini_entry , int type ))((void *)0)}};
zend_class_entry *date_ce_date  ;
zend_class_entry *date_ce_timezone  ;
zend_class_entry *date_ce_interval  ;
zend_class_entry *date_ce_period  ;
zend_class_entry __attribute__((__visibility__("default")))  *php_date_get_date_ce(void) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1158] == 0) {
    {
    fprintf(_coverage_fout, "1158\n");
    fflush(_coverage_fout);
    ___coverage_array[1158] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zend_class_entry __attribute__((__visibility__("default")))  *)date_ce_date);
}
}
zend_class_entry __attribute__((__visibility__("default")))  *php_date_get_timezone_ce(void) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1159] == 0) {
    {
    fprintf(_coverage_fout, "1159\n");
    fflush(_coverage_fout);
    ___coverage_array[1159] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zend_class_entry __attribute__((__visibility__("default")))  *)date_ce_timezone);
}
}
static zend_object_handlers date_object_handlers_date  ;
static zend_object_handlers date_object_handlers_timezone  ;
static zend_object_handlers date_object_handlers_interval  ;
static zend_object_handlers date_object_handlers_period  ;
static void date_object_free_storage_date(void *object ) ;
static void date_object_free_storage_timezone(void *object ) ;
static void date_object_free_storage_interval(void *object ) ;
static void date_object_free_storage_period(void *object ) ;
static zend_object_value date_object_new_date(zend_class_entry *class_type ) ;
static zend_object_value date_object_new_timezone(zend_class_entry *class_type ) ;
static zend_object_value date_object_new_interval(zend_class_entry *class_type ) ;
static zend_object_value date_object_new_period(zend_class_entry *class_type ) ;
static zend_object_value date_object_clone_date(zval *this_ptr ) ;
static zend_object_value date_object_clone_timezone(zval *this_ptr ) ;
static zend_object_value date_object_clone_interval(zval *this_ptr ) ;
static zend_object_value date_object_clone_period(zval *this_ptr ) ;
static int date_object_compare_date(zval *d1 , zval *d2 ) ;
static HashTable *date_object_get_properties(zval *object ) ;
static HashTable *date_object_get_properties_interval(zval *object ) ;
zval *date_interval_read_property(zval *object , zval *member , int type ,
                                  zend_literal const   *key ) ;
void date_interval_write_property(zval *object , zval *member , zval *value ,
                                  zend_literal const   *key ) ;
zend_module_entry date_module_entry  = 
     {(unsigned short )sizeof(zend_module_entry ), 20100525U, (unsigned char)0,
    (unsigned char)0, (struct _zend_ini_entry  const  *)((void *)0),
    (struct _zend_module_dep  const  *)((void *)0), "date", date_functions,
    & zm_startup_date, & zm_shutdown_date, & zm_activate_date,
    & zm_deactivate_date, & zm_info_date, "5.3.99-dev",
    sizeof(zend_date_globals ), (void *)(& date_globals),
    (void (*)(void * ))(& zm_globals_ctor_date),
    (void (*)(void *global ))((void *)0), (int (*)(void))((void *)0), 0,
    (unsigned char)0, (void *)0, 0, "API20100525,NTS"};
static void zm_globals_ctor_date(zend_date_globals *date_globals___0 ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1160] == 0) {
    {
    fprintf(_coverage_fout, "1160\n");
    fflush(_coverage_fout);
    ___coverage_array[1160] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals___0->default_timezone = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1161] == 0) {
    {
    fprintf(_coverage_fout, "1161\n");
    fflush(_coverage_fout);
    ___coverage_array[1161] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals___0->timezone = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1162] == 0) {
    {
    fprintf(_coverage_fout, "1162\n");
    fflush(_coverage_fout);
    ___coverage_array[1162] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals___0->tzcache = (HashTable *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1163] == 0) {
    {
    fprintf(_coverage_fout, "1163\n");
    fflush(_coverage_fout);
    ___coverage_array[1163] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void _php_date_tzinfo_dtor(void *tzinfo ) 
{ timelib_tzinfo **tzi ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1164] == 0) {
    {
    fprintf(_coverage_fout, "1164\n");
    fflush(_coverage_fout);
    ___coverage_array[1164] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo **)tzinfo;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1165] == 0) {
    {
    fprintf(_coverage_fout, "1165\n");
    fflush(_coverage_fout);
    ___coverage_array[1165] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_tzinfo_dtor(*tzi);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1166] == 0) {
    {
    fprintf(_coverage_fout, "1166\n");
    fflush(_coverage_fout);
    ___coverage_array[1166] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
int zm_activate_date(int type , int module_number ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1169] == 0) {
    {
    fprintf(_coverage_fout, "1169\n");
    fflush(_coverage_fout);
    ___coverage_array[1169] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.timezone) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1167] == 0) {
      {
      fprintf(_coverage_fout, "1167\n");
      fflush(_coverage_fout);
      ___coverage_array[1167] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)date_globals.timezone);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1168] == 0) {
      {
      fprintf(_coverage_fout, "1168\n");
      fflush(_coverage_fout);
      ___coverage_array[1168] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1170] == 0) {
    {
    fprintf(_coverage_fout, "1170\n");
    fflush(_coverage_fout);
    ___coverage_array[1170] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.timezone = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1171] == 0) {
    {
    fprintf(_coverage_fout, "1171\n");
    fflush(_coverage_fout);
    ___coverage_array[1171] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.tzcache = (HashTable *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1172] == 0) {
    {
    fprintf(_coverage_fout, "1172\n");
    fflush(_coverage_fout);
    ___coverage_array[1172] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.last_errors = (timelib_error_container *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1173] == 0) {
    {
    fprintf(_coverage_fout, "1173\n");
    fflush(_coverage_fout);
    ___coverage_array[1173] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
int zm_deactivate_date(int type , int module_number ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1183] == 0) {
    {
    fprintf(_coverage_fout, "1183\n");
    fflush(_coverage_fout);
    ___coverage_array[1183] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.timezone) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1174] == 0) {
      {
      fprintf(_coverage_fout, "1174\n");
      fflush(_coverage_fout);
      ___coverage_array[1174] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)date_globals.timezone);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1175] == 0) {
      {
      fprintf(_coverage_fout, "1175\n");
      fflush(_coverage_fout);
      ___coverage_array[1175] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1184] == 0) {
    {
    fprintf(_coverage_fout, "1184\n");
    fflush(_coverage_fout);
    ___coverage_array[1184] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.timezone = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1185] == 0) {
    {
    fprintf(_coverage_fout, "1185\n");
    fflush(_coverage_fout);
    ___coverage_array[1185] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.tzcache) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1176] == 0) {
      {
      fprintf(_coverage_fout, "1176\n");
      fflush(_coverage_fout);
      ___coverage_array[1176] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_hash_destroy(date_globals.tzcache);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1177] == 0) {
      {
      fprintf(_coverage_fout, "1177\n");
      fflush(_coverage_fout);
      ___coverage_array[1177] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)date_globals.tzcache);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1178] == 0) {
      {
      fprintf(_coverage_fout, "1178\n");
      fflush(_coverage_fout);
      ___coverage_array[1178] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    date_globals.tzcache = (HashTable *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1179] == 0) {
      {
      fprintf(_coverage_fout, "1179\n");
      fflush(_coverage_fout);
      ___coverage_array[1179] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1186] == 0) {
    {
    fprintf(_coverage_fout, "1186\n");
    fflush(_coverage_fout);
    ___coverage_array[1186] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.last_errors) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1180] == 0) {
      {
      fprintf(_coverage_fout, "1180\n");
      fflush(_coverage_fout);
      ___coverage_array[1180] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_error_container_dtor(date_globals.last_errors);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1181] == 0) {
      {
      fprintf(_coverage_fout, "1181\n");
      fflush(_coverage_fout);
      ___coverage_array[1181] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    date_globals.last_errors = (timelib_error_container *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1182] == 0) {
      {
      fprintf(_coverage_fout, "1182\n");
      fflush(_coverage_fout);
      ___coverage_array[1182] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1187] == 0) {
    {
    fprintf(_coverage_fout, "1187\n");
    fflush(_coverage_fout);
    ___coverage_array[1187] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
int zm_startup_date(int type , int module_number ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1188] == 0) {
    {
    fprintf(_coverage_fout, "1188\n");
    fflush(_coverage_fout);
    ___coverage_array[1188] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_ini_entries(ini_entries, module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1189] == 0) {
    {
    fprintf(_coverage_fout, "1189\n");
    fflush(_coverage_fout);
    ___coverage_array[1189] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_register_classes();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1190] == 0) {
    {
    fprintf(_coverage_fout, "1190\n");
    fflush(_coverage_fout);
    ___coverage_array[1190] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_ATOM", sizeof("DATE_ATOM"),
                                (char *)"Y-m-d\\TH:i:sP", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1191] == 0) {
    {
    fprintf(_coverage_fout, "1191\n");
    fflush(_coverage_fout);
    ___coverage_array[1191] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_COOKIE", sizeof("DATE_COOKIE"),
                                (char *)"l, d-M-y H:i:s T", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1192] == 0) {
    {
    fprintf(_coverage_fout, "1192\n");
    fflush(_coverage_fout);
    ___coverage_array[1192] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_ISO8601", sizeof("DATE_ISO8601"),
                                (char *)"Y-m-d\\TH:i:sO", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1193] == 0) {
    {
    fprintf(_coverage_fout, "1193\n");
    fflush(_coverage_fout);
    ___coverage_array[1193] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RFC822", sizeof("DATE_RFC822"),
                                (char *)"D, d M y H:i:s O", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1194] == 0) {
    {
    fprintf(_coverage_fout, "1194\n");
    fflush(_coverage_fout);
    ___coverage_array[1194] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RFC850", sizeof("DATE_RFC850"),
                                (char *)"l, d-M-y H:i:s T", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1195] == 0) {
    {
    fprintf(_coverage_fout, "1195\n");
    fflush(_coverage_fout);
    ___coverage_array[1195] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RFC1036", sizeof("DATE_RFC1036"),
                                (char *)"D, d M y H:i:s O", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1196] == 0) {
    {
    fprintf(_coverage_fout, "1196\n");
    fflush(_coverage_fout);
    ___coverage_array[1196] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RFC1123", sizeof("DATE_RFC1123"),
                                (char *)"D, d M Y H:i:s O", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1197] == 0) {
    {
    fprintf(_coverage_fout, "1197\n");
    fflush(_coverage_fout);
    ___coverage_array[1197] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RFC2822", sizeof("DATE_RFC2822"),
                                (char *)"D, d M Y H:i:s O", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1198] == 0) {
    {
    fprintf(_coverage_fout, "1198\n");
    fflush(_coverage_fout);
    ___coverage_array[1198] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RFC3339", sizeof("DATE_RFC3339"),
                                (char *)"Y-m-d\\TH:i:sP", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1199] == 0) {
    {
    fprintf(_coverage_fout, "1199\n");
    fflush(_coverage_fout);
    ___coverage_array[1199] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_RSS", sizeof("DATE_RSS"),
                                (char *)"D, d M Y H:i:s O", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1200] == 0) {
    {
    fprintf(_coverage_fout, "1200\n");
    fflush(_coverage_fout);
    ___coverage_array[1200] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_string_constant("DATE_W3C", sizeof("DATE_W3C"),
                                (char *)"Y-m-d\\TH:i:sP", 1 | (1 << 1),
                                module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1201] == 0) {
    {
    fprintf(_coverage_fout, "1201\n");
    fflush(_coverage_fout);
    ___coverage_array[1201] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_long_constant("SUNFUNCS_RET_TIMESTAMP",
                              sizeof("SUNFUNCS_RET_TIMESTAMP"), 0L,
                              1 | (1 << 1), module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1202] == 0) {
    {
    fprintf(_coverage_fout, "1202\n");
    fflush(_coverage_fout);
    ___coverage_array[1202] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_long_constant("SUNFUNCS_RET_STRING",
                              sizeof("SUNFUNCS_RET_STRING"), 1L, 1 | (1 << 1),
                              module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1203] == 0) {
    {
    fprintf(_coverage_fout, "1203\n");
    fflush(_coverage_fout);
    ___coverage_array[1203] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_register_long_constant("SUNFUNCS_RET_DOUBLE",
                              sizeof("SUNFUNCS_RET_DOUBLE"), 2L, 1 | (1 << 1),
                              module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1204] == 0) {
    {
    fprintf(_coverage_fout, "1204\n");
    fflush(_coverage_fout);
    ___coverage_array[1204] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_global_timezone_db = (timelib_tzdb *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1205] == 0) {
    {
    fprintf(_coverage_fout, "1205\n");
    fflush(_coverage_fout);
    ___coverage_array[1205] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_global_timezone_db_enabled = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1206] == 0) {
    {
    fprintf(_coverage_fout, "1206\n");
    fflush(_coverage_fout);
    ___coverage_array[1206] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.last_errors = (timelib_error_container *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1207] == 0) {
    {
    fprintf(_coverage_fout, "1207\n");
    fflush(_coverage_fout);
    ___coverage_array[1207] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
int zm_shutdown_date(int type , int module_number ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1210] == 0) {
    {
    fprintf(_coverage_fout, "1210\n");
    fflush(_coverage_fout);
    ___coverage_array[1210] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_unregister_ini_entries(module_number);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1211] == 0) {
    {
    fprintf(_coverage_fout, "1211\n");
    fflush(_coverage_fout);
    ___coverage_array[1211] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.last_errors) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1208] == 0) {
      {
      fprintf(_coverage_fout, "1208\n");
      fflush(_coverage_fout);
      ___coverage_array[1208] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_error_container_dtor(date_globals.last_errors);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1209] == 0) {
      {
      fprintf(_coverage_fout, "1209\n");
      fflush(_coverage_fout);
      ___coverage_array[1209] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1212] == 0) {
    {
    fprintf(_coverage_fout, "1212\n");
    fflush(_coverage_fout);
    ___coverage_array[1212] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
void zm_info_date(zend_module_entry *zend_module ) 
{ timelib_tzdb const   *tzdb ;
  timelib_tzdb const   *tmp ;
  timelib_tzdb const   *tmp___0 ;
  char const   *tmp___1 ;
  char *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1218] == 0) {
    {
    fprintf(_coverage_fout, "1218\n");
    fflush(_coverage_fout);
    ___coverage_array[1218] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1213] == 0) {
      {
      fprintf(_coverage_fout, "1213\n");
      fflush(_coverage_fout);
      ___coverage_array[1213] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1214] == 0) {
      {
      fprintf(_coverage_fout, "1214\n");
      fflush(_coverage_fout);
      ___coverage_array[1214] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1215] == 0) {
      {
      fprintf(_coverage_fout, "1215\n");
      fflush(_coverage_fout);
      ___coverage_array[1215] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1219] == 0) {
    {
    fprintf(_coverage_fout, "1219\n");
    fflush(_coverage_fout);
    ___coverage_array[1219] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzdb = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1220] == 0) {
    {
    fprintf(_coverage_fout, "1220\n");
    fflush(_coverage_fout);
    ___coverage_array[1220] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_info_print_table_start();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1221] == 0) {
    {
    fprintf(_coverage_fout, "1221\n");
    fflush(_coverage_fout);
    ___coverage_array[1221] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_info_print_table_row(2, "date/time support", "enabled");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1222] == 0) {
    {
    fprintf(_coverage_fout, "1222\n");
    fflush(_coverage_fout);
    ___coverage_array[1222] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_info_print_table_row(2, "\"Olson\" Timezone Database Version",
                           tzdb->version);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1223] == 0) {
    {
    fprintf(_coverage_fout, "1223\n");
    fflush(_coverage_fout);
    ___coverage_array[1223] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db_enabled) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1216] == 0) {
      {
      fprintf(_coverage_fout, "1216\n");
      fflush(_coverage_fout);
      ___coverage_array[1216] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = "external";
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1217] == 0) {
      {
      fprintf(_coverage_fout, "1217\n");
      fflush(_coverage_fout);
      ___coverage_array[1217] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = "internal";
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1224] == 0) {
    {
    fprintf(_coverage_fout, "1224\n");
    fflush(_coverage_fout);
    ___coverage_array[1224] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_info_print_table_row(2, "Timezone Database", tmp___1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1225] == 0) {
    {
    fprintf(_coverage_fout, "1225\n");
    fflush(_coverage_fout);
    ___coverage_array[1225] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = guess_timezone(tzdb);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1226] == 0) {
    {
    fprintf(_coverage_fout, "1226\n");
    fflush(_coverage_fout);
    ___coverage_array[1226] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_info_print_table_row(2, "Default timezone", tmp___2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1227] == 0) {
    {
    fprintf(_coverage_fout, "1227\n");
    fflush(_coverage_fout);
    ___coverage_array[1227] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_info_print_table_end();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1228] == 0) {
    {
    fprintf(_coverage_fout, "1228\n");
    fflush(_coverage_fout);
    ___coverage_array[1228] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  display_ini_entries(zend_module);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1229] == 0) {
    {
    fprintf(_coverage_fout, "1229\n");
    fflush(_coverage_fout);
    ___coverage_array[1229] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static timelib_tzinfo *php_date_parse_tzfile(char *formal_tzname ,
                                             timelib_tzdb const   *tzdb ) 
{ timelib_tzinfo *tzi ;
  timelib_tzinfo **ptzi ;
  void __attribute__((__visibility__("default")))  *tmp ;
  size_t tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  size_t tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1239] == 0) {
    {
    fprintf(_coverage_fout, "1239\n");
    fflush(_coverage_fout);
    ___coverage_array[1239] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! date_globals.tzcache) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1230] == 0) {
      {
      fprintf(_coverage_fout, "1230\n");
      fflush(_coverage_fout);
      ___coverage_array[1230] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = _emalloc(sizeof(HashTable ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1231] == 0) {
      {
      fprintf(_coverage_fout, "1231\n");
      fflush(_coverage_fout);
      ___coverage_array[1231] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    date_globals.tzcache = (HashTable *)tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1232] == 0) {
      {
      fprintf(_coverage_fout, "1232\n");
      fflush(_coverage_fout);
      ___coverage_array[1232] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_init(date_globals.tzcache, 4U,
                    (ulong (*)(char const   *arKey , uint nKeyLength ))((void *)0),
                    & _php_date_tzinfo_dtor, (unsigned char)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1233] == 0) {
      {
      fprintf(_coverage_fout, "1233\n");
      fflush(_coverage_fout);
      ___coverage_array[1233] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1240] == 0) {
    {
    fprintf(_coverage_fout, "1240\n");
    fflush(_coverage_fout);
    ___coverage_array[1240] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = strlen((char const   *)formal_tzname);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1241] == 0) {
    {
    fprintf(_coverage_fout, "1241\n");
    fflush(_coverage_fout);
    ___coverage_array[1241] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_hash_find((HashTable const   *)date_globals.tzcache,
                           (char const   *)formal_tzname, tmp___0 + 1U,
                           (void **)(& ptzi));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1242] == 0) {
    {
    fprintf(_coverage_fout, "1242\n");
    fflush(_coverage_fout);
    ___coverage_array[1242] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1234] == 0) {
      {
      fprintf(_coverage_fout, "1234\n");
      fflush(_coverage_fout);
      ___coverage_array[1234] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (*ptzi);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1235] == 0) {
      {
      fprintf(_coverage_fout, "1235\n");
      fflush(_coverage_fout);
      ___coverage_array[1235] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1243] == 0) {
    {
    fprintf(_coverage_fout, "1243\n");
    fflush(_coverage_fout);
    ___coverage_array[1243] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = timelib_parse_tzfile(formal_tzname, tzdb);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1244] == 0) {
    {
    fprintf(_coverage_fout, "1244\n");
    fflush(_coverage_fout);
    ___coverage_array[1244] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tzi) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1236] == 0) {
      {
      fprintf(_coverage_fout, "1236\n");
      fflush(_coverage_fout);
      ___coverage_array[1236] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = strlen((char const   *)formal_tzname);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1237] == 0) {
      {
      fprintf(_coverage_fout, "1237\n");
      fflush(_coverage_fout);
      ___coverage_array[1237] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_add_or_update(date_globals.tzcache,
                             (char const   *)formal_tzname, tmp___2 + 1U,
                             (void *)(& tzi), sizeof(timelib_tzinfo *),
                             (void **)((void *)0), 1 << 1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1238] == 0) {
      {
      fprintf(_coverage_fout, "1238\n");
      fflush(_coverage_fout);
      ___coverage_array[1238] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1245] == 0) {
    {
    fprintf(_coverage_fout, "1245\n");
    fflush(_coverage_fout);
    ___coverage_array[1245] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tzi);
}
}
static char *guess_timezone(timelib_tzdb const   *tzdb ) 
{ char *env ;
  size_t tmp ;
  int tmp___0 ;
  zval ztz ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  struct tm *ta ;
  struct tm tmbuf ;
  time_t the_time ;
  char *tzid ;
  char const   *tmp___4 ;
  char const   *tmp___5 ;
  float tmp___6 ;
  char const   *tmp___7 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1288] == 0) {
    {
    fprintf(_coverage_fout, "1288\n");
    fflush(_coverage_fout);
    ___coverage_array[1288] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.timezone) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1248] == 0) {
      {
      fprintf(_coverage_fout, "1248\n");
      fflush(_coverage_fout);
      ___coverage_array[1248] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = strlen((char const   *)date_globals.timezone);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1249] == 0) {
      {
      fprintf(_coverage_fout, "1249\n");
      fflush(_coverage_fout);
      ___coverage_array[1249] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp > 0U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1246] == 0) {
        {
        fprintf(_coverage_fout, "1246\n");
        fflush(_coverage_fout);
        ___coverage_array[1246] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (date_globals.timezone);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1247] == 0) {
        {
        fprintf(_coverage_fout, "1247\n");
        fflush(_coverage_fout);
        ___coverage_array[1247] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1250] == 0) {
      {
      fprintf(_coverage_fout, "1250\n");
      fflush(_coverage_fout);
      ___coverage_array[1250] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1289] == 0) {
    {
    fprintf(_coverage_fout, "1289\n");
    fflush(_coverage_fout);
    ___coverage_array[1289] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  env = getenv("TZ");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1290] == 0) {
    {
    fprintf(_coverage_fout, "1290\n");
    fflush(_coverage_fout);
    ___coverage_array[1290] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (env) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1256] == 0) {
      {
      fprintf(_coverage_fout, "1256\n");
      fflush(_coverage_fout);
      ___coverage_array[1256] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (*env) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1253] == 0) {
        {
        fprintf(_coverage_fout, "1253\n");
        fflush(_coverage_fout);
        ___coverage_array[1253] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = timelib_timezone_id_is_valid(env, tzdb);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1254] == 0) {
        {
        fprintf(_coverage_fout, "1254\n");
        fflush(_coverage_fout);
        ___coverage_array[1254] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1251] == 0) {
          {
          fprintf(_coverage_fout, "1251\n");
          fflush(_coverage_fout);
          ___coverage_array[1251] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (env);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1252] == 0) {
          {
          fprintf(_coverage_fout, "1252\n");
          fflush(_coverage_fout);
          ___coverage_array[1252] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1255] == 0) {
        {
        fprintf(_coverage_fout, "1255\n");
        fflush(_coverage_fout);
        ___coverage_array[1255] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1257] == 0) {
      {
      fprintf(_coverage_fout, "1257\n");
      fflush(_coverage_fout);
      ___coverage_array[1257] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1291] == 0) {
    {
    fprintf(_coverage_fout, "1291\n");
    fflush(_coverage_fout);
    ___coverage_array[1291] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! date_globals.default_timezone) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1267] == 0) {
      {
      fprintf(_coverage_fout, "1267\n");
      fflush(_coverage_fout);
      ___coverage_array[1267] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = zend_get_configuration_directive("date.timezone",
                                               sizeof("date.timezone"), & ztz);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1268] == 0) {
      {
      fprintf(_coverage_fout, "1268\n");
      fflush(_coverage_fout);
      ___coverage_array[1268] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0 == (int )tmp___1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1265] == 0) {
        {
        fprintf(_coverage_fout, "1265\n");
        fflush(_coverage_fout);
        ___coverage_array[1265] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )ztz.type == 6) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1263] == 0) {
          {
          fprintf(_coverage_fout, "1263\n");
          fflush(_coverage_fout);
          ___coverage_array[1263] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (ztz.value.str.len > 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1260] == 0) {
            {
            fprintf(_coverage_fout, "1260\n");
            fflush(_coverage_fout);
            ___coverage_array[1260] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___2 = timelib_timezone_id_is_valid(ztz.value.str.val, tzdb);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1261] == 0) {
            {
            fprintf(_coverage_fout, "1261\n");
            fflush(_coverage_fout);
            ___coverage_array[1261] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (tmp___2) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1258] == 0) {
              {
              fprintf(_coverage_fout, "1258\n");
              fflush(_coverage_fout);
              ___coverage_array[1258] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            return (ztz.value.str.val);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1259] == 0) {
              {
              fprintf(_coverage_fout, "1259\n");
              fflush(_coverage_fout);
              ___coverage_array[1259] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1262] == 0) {
            {
            fprintf(_coverage_fout, "1262\n");
            fflush(_coverage_fout);
            ___coverage_array[1262] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1264] == 0) {
          {
          fprintf(_coverage_fout, "1264\n");
          fflush(_coverage_fout);
          ___coverage_array[1264] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1266] == 0) {
        {
        fprintf(_coverage_fout, "1266\n");
        fflush(_coverage_fout);
        ___coverage_array[1266] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1274] == 0) {
      {
      fprintf(_coverage_fout, "1274\n");
      fflush(_coverage_fout);
      ___coverage_array[1274] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (*(date_globals.default_timezone)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1271] == 0) {
        {
        fprintf(_coverage_fout, "1271\n");
        fflush(_coverage_fout);
        ___coverage_array[1271] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___3 = timelib_timezone_id_is_valid(date_globals.default_timezone, tzdb);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1272] == 0) {
        {
        fprintf(_coverage_fout, "1272\n");
        fflush(_coverage_fout);
        ___coverage_array[1272] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___3) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1269] == 0) {
          {
          fprintf(_coverage_fout, "1269\n");
          fflush(_coverage_fout);
          ___coverage_array[1269] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (date_globals.default_timezone);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1270] == 0) {
          {
          fprintf(_coverage_fout, "1270\n");
          fflush(_coverage_fout);
          ___coverage_array[1270] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1273] == 0) {
        {
        fprintf(_coverage_fout, "1273\n");
        fflush(_coverage_fout);
        ___coverage_array[1273] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1292] == 0) {
    {
    fprintf(_coverage_fout, "1292\n");
    fflush(_coverage_fout);
    ___coverage_array[1292] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzid = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1293] == 0) {
    {
    fprintf(_coverage_fout, "1293\n");
    fflush(_coverage_fout);
    ___coverage_array[1293] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  the_time = time((time_t *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1294] == 0) {
    {
    fprintf(_coverage_fout, "1294\n");
    fflush(_coverage_fout);
    ___coverage_array[1294] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta = localtime_r((time_t const   */* __restrict  */)(& the_time),
                   (struct tm */* __restrict  */)(& tmbuf));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1295] == 0) {
    {
    fprintf(_coverage_fout, "1295\n");
    fflush(_coverage_fout);
    ___coverage_array[1295] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ta) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1275] == 0) {
      {
      fprintf(_coverage_fout, "1275\n");
      fflush(_coverage_fout);
      ___coverage_array[1275] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzid = timelib_timezone_id_from_abbr(ta->tm_zone, ta->tm_gmtoff,
                                         ta->tm_isdst);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1276] == 0) {
      {
      fprintf(_coverage_fout, "1276\n");
      fflush(_coverage_fout);
      ___coverage_array[1276] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1296] == 0) {
    {
    fprintf(_coverage_fout, "1296\n");
    fflush(_coverage_fout);
    ___coverage_array[1296] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! tzid) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1277] == 0) {
      {
      fprintf(_coverage_fout, "1277\n");
      fflush(_coverage_fout);
      ___coverage_array[1277] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzid = (char *)"UTC";
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1278] == 0) {
      {
      fprintf(_coverage_fout, "1278\n");
      fflush(_coverage_fout);
      ___coverage_array[1278] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1297] == 0) {
    {
    fprintf(_coverage_fout, "1297\n");
    fflush(_coverage_fout);
    ___coverage_array[1297] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ta) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1281] == 0) {
      {
      fprintf(_coverage_fout, "1281\n");
      fflush(_coverage_fout);
      ___coverage_array[1281] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (ta->tm_isdst) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1279] == 0) {
        {
        fprintf(_coverage_fout, "1279\n");
        fflush(_coverage_fout);
        ___coverage_array[1279] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = "DST";
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1280] == 0) {
        {
        fprintf(_coverage_fout, "1280\n");
        fflush(_coverage_fout);
        ___coverage_array[1280] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = "no DST";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1282] == 0) {
      {
      fprintf(_coverage_fout, "1282\n");
      fflush(_coverage_fout);
      ___coverage_array[1282] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = tmp___4;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1283] == 0) {
      {
      fprintf(_coverage_fout, "1283\n");
      fflush(_coverage_fout);
      ___coverage_array[1283] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = "Unknown";
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1298] == 0) {
    {
    fprintf(_coverage_fout, "1298\n");
    fflush(_coverage_fout);
    ___coverage_array[1298] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ta) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1284] == 0) {
      {
      fprintf(_coverage_fout, "1284\n");
      fflush(_coverage_fout);
      ___coverage_array[1284] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = (float )(ta->tm_gmtoff / 3600L);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1285] == 0) {
      {
      fprintf(_coverage_fout, "1285\n");
      fflush(_coverage_fout);
      ___coverage_array[1285] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = (float )0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1299] == 0) {
    {
    fprintf(_coverage_fout, "1299\n");
    fflush(_coverage_fout);
    ___coverage_array[1299] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ta) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1286] == 0) {
      {
      fprintf(_coverage_fout, "1286\n");
      fflush(_coverage_fout);
      ___coverage_array[1286] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = ta->tm_zone;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1287] == 0) {
      {
      fprintf(_coverage_fout, "1287\n");
      fflush(_coverage_fout);
      ___coverage_array[1287] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = "Unknown";
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1300] == 0) {
    {
    fprintf(_coverage_fout, "1300\n");
    fflush(_coverage_fout);
    ___coverage_array[1300] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_error_docref0((char const   *)((void *)0), 1 << 1L,
                    "It is not safe to rely on the system\'s timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected \'%s\' for \'%s/%.1f/%s\' instead",
                    tzid, tmp___7, tmp___6, tmp___5);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1301] == 0) {
    {
    fprintf(_coverage_fout, "1301\n");
    fflush(_coverage_fout);
    ___coverage_array[1301] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tzid);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1302] == 0) {
    {
    fprintf(_coverage_fout, "1302\n");
    fflush(_coverage_fout);
    ___coverage_array[1302] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_error_docref0((char const   *)((void *)0), 1 << 1L,
                    "It is not safe to rely on the system\'s timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We had to select \'UTC\' because your platform doesn\'t provide functionality for the guessing algorithm");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1303] == 0) {
    {
    fprintf(_coverage_fout, "1303\n");
    fflush(_coverage_fout);
    ___coverage_array[1303] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((char *)"UTC");
}
}
timelib_tzinfo __attribute__((__visibility__("default")))  *get_timezone_info(void) 
{ char *tz ;
  timelib_tzinfo *tzi ;
  timelib_tzdb const   *tmp ;
  timelib_tzdb const   *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;
  timelib_tzdb const   *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1312] == 0) {
    {
    fprintf(_coverage_fout, "1312\n");
    fflush(_coverage_fout);
    ___coverage_array[1312] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1304] == 0) {
      {
      fprintf(_coverage_fout, "1304\n");
      fflush(_coverage_fout);
      ___coverage_array[1304] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1305] == 0) {
      {
      fprintf(_coverage_fout, "1305\n");
      fflush(_coverage_fout);
      ___coverage_array[1305] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1306] == 0) {
      {
      fprintf(_coverage_fout, "1306\n");
      fflush(_coverage_fout);
      ___coverage_array[1306] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1313] == 0) {
    {
    fprintf(_coverage_fout, "1313\n");
    fflush(_coverage_fout);
    ___coverage_array[1313] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tz = guess_timezone(tmp___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1314] == 0) {
    {
    fprintf(_coverage_fout, "1314\n");
    fflush(_coverage_fout);
    ___coverage_array[1314] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1307] == 0) {
      {
      fprintf(_coverage_fout, "1307\n");
      fflush(_coverage_fout);
      ___coverage_array[1307] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1308] == 0) {
      {
      fprintf(_coverage_fout, "1308\n");
      fflush(_coverage_fout);
      ___coverage_array[1308] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1309] == 0) {
      {
      fprintf(_coverage_fout, "1309\n");
      fflush(_coverage_fout);
      ___coverage_array[1309] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___1;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1315] == 0) {
    {
    fprintf(_coverage_fout, "1315\n");
    fflush(_coverage_fout);
    ___coverage_array[1315] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = php_date_parse_tzfile(tz, tmp___2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1316] == 0) {
    {
    fprintf(_coverage_fout, "1316\n");
    fflush(_coverage_fout);
    ___coverage_array[1316] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! tzi) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1310] == 0) {
      {
      fprintf(_coverage_fout, "1310\n");
      fflush(_coverage_fout);
      ___coverage_array[1310] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1,
                      "Timezone database is corrupt - this should *never* happen!");
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1311] == 0) {
      {
      fprintf(_coverage_fout, "1311\n");
      fflush(_coverage_fout);
      ___coverage_array[1311] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1317] == 0) {
    {
    fprintf(_coverage_fout, "1317\n");
    fflush(_coverage_fout);
    ___coverage_array[1317] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((timelib_tzinfo __attribute__((__visibility__("default")))  *)tzi);
}
}
__inline static char *smart_str_print_long(char *buf , long num ) 
{ char *r ;
  char *__p ;
  unsigned long __num ;
  char *__p___0 ;
  unsigned long __num___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1343] == 0) {
    {
    fprintf(_coverage_fout, "1343\n");
    fflush(_coverage_fout);
    ___coverage_array[1343] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1342] == 0) {
      {
      fprintf(_coverage_fout, "1342\n");
      fflush(_coverage_fout);
      ___coverage_array[1342] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (num < 0L) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1328] == 0) {
        {
        fprintf(_coverage_fout, "1328\n");
        fflush(_coverage_fout);
        ___coverage_array[1328] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1323] == 0) {
          {
          fprintf(_coverage_fout, "1323\n");
          fflush(_coverage_fout);
          ___coverage_array[1323] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __p = buf;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1324] == 0) {
          {
          fprintf(_coverage_fout, "1324\n");
          fflush(_coverage_fout);
          ___coverage_array[1324] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __num = (unsigned long )(- num);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1325] == 0) {
          {
          fprintf(_coverage_fout, "1325\n");
          fflush(_coverage_fout);
          ___coverage_array[1325] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *__p = (char )'\000';
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1326] == 0) {
          {
          fprintf(_coverage_fout, "1326\n");
          fflush(_coverage_fout);
          ___coverage_array[1326] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1319] == 0) {
            {
            fprintf(_coverage_fout, "1319\n");
            fflush(_coverage_fout);
            ___coverage_array[1319] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __p --;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1320] == 0) {
            {
            fprintf(_coverage_fout, "1320\n");
            fflush(_coverage_fout);
            ___coverage_array[1320] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *__p = (char )((int )((char )(__num % 10UL)) + 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1321] == 0) {
            {
            fprintf(_coverage_fout, "1321\n");
            fflush(_coverage_fout);
            ___coverage_array[1321] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __num /= 10UL;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1322] == 0) {
            {
            fprintf(_coverage_fout, "1322\n");
            fflush(_coverage_fout);
            ___coverage_array[1322] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (__num > 0UL) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1318] == 0) {
              {
              fprintf(_coverage_fout, "1318\n");
              fflush(_coverage_fout);
              ___coverage_array[1318] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1327] == 0) {
          {
          fprintf(_coverage_fout, "1327\n");
          fflush(_coverage_fout);
          ___coverage_array[1327] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        r = __p;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1329] == 0) {
        {
        fprintf(_coverage_fout, "1329\n");
        fflush(_coverage_fout);
        ___coverage_array[1329] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      r --;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1330] == 0) {
        {
        fprintf(_coverage_fout, "1330\n");
        fflush(_coverage_fout);
        ___coverage_array[1330] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *r = (char )'-';
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1341] == 0) {
        {
        fprintf(_coverage_fout, "1341\n");
        fflush(_coverage_fout);
        ___coverage_array[1341] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1336] == 0) {
          {
          fprintf(_coverage_fout, "1336\n");
          fflush(_coverage_fout);
          ___coverage_array[1336] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __p___0 = buf;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1337] == 0) {
          {
          fprintf(_coverage_fout, "1337\n");
          fflush(_coverage_fout);
          ___coverage_array[1337] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __num___0 = (unsigned long )num;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1338] == 0) {
          {
          fprintf(_coverage_fout, "1338\n");
          fflush(_coverage_fout);
          ___coverage_array[1338] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *__p___0 = (char )'\000';
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1339] == 0) {
          {
          fprintf(_coverage_fout, "1339\n");
          fflush(_coverage_fout);
          ___coverage_array[1339] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1332] == 0) {
            {
            fprintf(_coverage_fout, "1332\n");
            fflush(_coverage_fout);
            ___coverage_array[1332] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __p___0 --;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1333] == 0) {
            {
            fprintf(_coverage_fout, "1333\n");
            fflush(_coverage_fout);
            ___coverage_array[1333] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *__p___0 = (char )((int )((char )(__num___0 % 10UL)) + 48);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1334] == 0) {
            {
            fprintf(_coverage_fout, "1334\n");
            fflush(_coverage_fout);
            ___coverage_array[1334] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __num___0 /= 10UL;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1335] == 0) {
            {
            fprintf(_coverage_fout, "1335\n");
            fflush(_coverage_fout);
            ___coverage_array[1335] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (__num___0 > 0UL) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1331] == 0) {
              {
              fprintf(_coverage_fout, "1331\n");
              fflush(_coverage_fout);
              ___coverage_array[1331] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          } else {
            break;
          }
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1340] == 0) {
          {
          fprintf(_coverage_fout, "1340\n");
          fflush(_coverage_fout);
          ___coverage_array[1340] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        r = __p___0;
        break;
      }
    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1344] == 0) {
    {
    fprintf(_coverage_fout, "1344\n");
    fflush(_coverage_fout);
    ___coverage_array[1344] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (r);
}
}
__inline static char *smart_str_print_unsigned(char *buf , long num ) 
{ char *r ;
  char *__p ;
  unsigned long __num ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1355] == 0) {
    {
    fprintf(_coverage_fout, "1355\n");
    fflush(_coverage_fout);
    ___coverage_array[1355] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1350] == 0) {
      {
      fprintf(_coverage_fout, "1350\n");
      fflush(_coverage_fout);
      ___coverage_array[1350] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __p = buf;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1351] == 0) {
      {
      fprintf(_coverage_fout, "1351\n");
      fflush(_coverage_fout);
      ___coverage_array[1351] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __num = (unsigned long )num;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1352] == 0) {
      {
      fprintf(_coverage_fout, "1352\n");
      fflush(_coverage_fout);
      ___coverage_array[1352] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *__p = (char )'\000';
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1353] == 0) {
      {
      fprintf(_coverage_fout, "1353\n");
      fflush(_coverage_fout);
      ___coverage_array[1353] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1346] == 0) {
        {
        fprintf(_coverage_fout, "1346\n");
        fflush(_coverage_fout);
        ___coverage_array[1346] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __p --;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1347] == 0) {
        {
        fprintf(_coverage_fout, "1347\n");
        fflush(_coverage_fout);
        ___coverage_array[1347] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *__p = (char )((int )((char )(__num % 10UL)) + 48);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1348] == 0) {
        {
        fprintf(_coverage_fout, "1348\n");
        fflush(_coverage_fout);
        ___coverage_array[1348] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __num /= 10UL;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1349] == 0) {
        {
        fprintf(_coverage_fout, "1349\n");
        fflush(_coverage_fout);
        ___coverage_array[1349] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (__num > 0UL) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1345] == 0) {
          {
          fprintf(_coverage_fout, "1345\n");
          fflush(_coverage_fout);
          ___coverage_array[1345] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1354] == 0) {
      {
      fprintf(_coverage_fout, "1354\n");
      fflush(_coverage_fout);
      ___coverage_array[1354] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    r = __p;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1356] == 0) {
    {
    fprintf(_coverage_fout, "1356\n");
    fflush(_coverage_fout);
    ___coverage_array[1356] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (r);
}
}
static char *mon_full_names[12]  = 
  {      (char *)"January",      (char *)"February",      (char *)"March",      (char *)"April", 
        (char *)"May",      (char *)"June",      (char *)"July",      (char *)"August", 
        (char *)"September",      (char *)"October",      (char *)"November",      (char *)"December"};
static char *mon_short_names[12]  = 
  {      (char *)"Jan",      (char *)"Feb",      (char *)"Mar",      (char *)"Apr", 
        (char *)"May",      (char *)"Jun",      (char *)"Jul",      (char *)"Aug", 
        (char *)"Sep",      (char *)"Oct",      (char *)"Nov",      (char *)"Dec"};
static char *day_full_names[7]  = {      (char *)"Sunday",      (char *)"Monday",      (char *)"Tuesday",      (char *)"Wednesday", 
        (char *)"Thursday",      (char *)"Friday",      (char *)"Saturday"};
static char *day_short_names[7]  = {      (char *)"Sun",      (char *)"Mon",      (char *)"Tue",      (char *)"Wed", 
        (char *)"Thu",      (char *)"Fri",      (char *)"Sat"};
static char *english_suffix(timelib_sll number ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1362] == 0) {
    {
    fprintf(_coverage_fout, "1362\n");
    fflush(_coverage_fout);
    ___coverage_array[1362] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (number >= 10LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1358] == 0) {
      {
      fprintf(_coverage_fout, "1358\n");
      fflush(_coverage_fout);
      ___coverage_array[1358] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (number <= 19LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1357] == 0) {
        {
        fprintf(_coverage_fout, "1357\n");
        fflush(_coverage_fout);
        ___coverage_array[1357] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((char *)"th");
    } else {
      goto _L;
    }
  } else {
    _L: /* CIL Label */ 
    switch ((int )(number % 10LL)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1359] == 0) {
      {
      fprintf(_coverage_fout, "1359\n");
      fflush(_coverage_fout);
      ___coverage_array[1359] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 1: 
    return ((char *)"st");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1360] == 0) {
      {
      fprintf(_coverage_fout, "1360\n");
      fflush(_coverage_fout);
      ___coverage_array[1360] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 2: 
    return ((char *)"nd");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1361] == 0) {
      {
      fprintf(_coverage_fout, "1361\n");
      fflush(_coverage_fout);
      ___coverage_array[1361] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 3: 
    return ((char *)"rd");
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1363] == 0) {
    {
    fprintf(_coverage_fout, "1363\n");
    fflush(_coverage_fout);
    ___coverage_array[1363] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((char *)"th");
}
}
char *php_date_full_day_name(timelib_sll y , timelib_sll m , timelib_sll d ) 
{ timelib_sll day_of_week ;
  timelib_sll tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1366] == 0) {
    {
    fprintf(_coverage_fout, "1366\n");
    fflush(_coverage_fout);
    ___coverage_array[1366] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = timelib_day_of_week(y, m, d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1367] == 0) {
    {
    fprintf(_coverage_fout, "1367\n");
    fflush(_coverage_fout);
    ___coverage_array[1367] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  day_of_week = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1368] == 0) {
    {
    fprintf(_coverage_fout, "1368\n");
    fflush(_coverage_fout);
    ___coverage_array[1368] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (day_of_week < 0LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1364] == 0) {
      {
      fprintf(_coverage_fout, "1364\n");
      fflush(_coverage_fout);
      ___coverage_array[1364] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)"Unknown");
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1365] == 0) {
      {
      fprintf(_coverage_fout, "1365\n");
      fflush(_coverage_fout);
      ___coverage_array[1365] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1369] == 0) {
    {
    fprintf(_coverage_fout, "1369\n");
    fflush(_coverage_fout);
    ___coverage_array[1369] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (day_full_names[day_of_week]);
}
}
char *php_date_short_day_name(timelib_sll y , timelib_sll m , timelib_sll d ) 
{ timelib_sll day_of_week ;
  timelib_sll tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1372] == 0) {
    {
    fprintf(_coverage_fout, "1372\n");
    fflush(_coverage_fout);
    ___coverage_array[1372] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = timelib_day_of_week(y, m, d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1373] == 0) {
    {
    fprintf(_coverage_fout, "1373\n");
    fflush(_coverage_fout);
    ___coverage_array[1373] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  day_of_week = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1374] == 0) {
    {
    fprintf(_coverage_fout, "1374\n");
    fflush(_coverage_fout);
    ___coverage_array[1374] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (day_of_week < 0LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1370] == 0) {
      {
      fprintf(_coverage_fout, "1370\n");
      fflush(_coverage_fout);
      ___coverage_array[1370] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)"Unknown");
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1371] == 0) {
      {
      fprintf(_coverage_fout, "1371\n");
      fflush(_coverage_fout);
      ___coverage_array[1371] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1375] == 0) {
    {
    fprintf(_coverage_fout, "1375\n");
    fflush(_coverage_fout);
    ___coverage_array[1375] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (day_short_names[day_of_week]);
}
}
static char *date_format(char *format , int format_len , timelib_time *t ,
                         int localtime___0 ) 
{ smart_str string ;
  int i ;
  int length ;
  char buffer[97] ;
  timelib_time_offset *offset ;
  timelib_sll isoweek ;
  timelib_sll isoyear ;
  int rfc_colon ;
  char __attribute__((__visibility__("default")))  *tmp ;
  void *tmp___0 ;
  size_t __len ;
  size_t tmp___1 ;
  char *__retval ;
  void *tmp___2 ;
  void *tmp___3 ;
  char *tmp___4 ;
  char *tmp___5 ;
  void *tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  int tmp___10 ;
  int tmp___11 ;
  int tmp___12 ;
  int __attribute__((__visibility__("default")))  tmp___13 ;
  char *tmp___14 ;
  int __attribute__((__visibility__("default")))  tmp___15 ;
  int __attribute__((__visibility__("default")))  tmp___16 ;
  char *tmp___17 ;
  int __attribute__((__visibility__("default")))  tmp___18 ;
  char *tmp___19 ;
  int __attribute__((__visibility__("default")))  tmp___20 ;
  timelib_sll tmp___21 ;
  int __attribute__((__visibility__("default")))  tmp___22 ;
  timelib_sll tmp___23 ;
  int __attribute__((__visibility__("default")))  tmp___24 ;
  timelib_sll tmp___25 ;
  int __attribute__((__visibility__("default")))  tmp___26 ;
  int __attribute__((__visibility__("default")))  tmp___27 ;
  int __attribute__((__visibility__("default")))  tmp___28 ;
  int __attribute__((__visibility__("default")))  tmp___29 ;
  int __attribute__((__visibility__("default")))  tmp___30 ;
  int __attribute__((__visibility__("default")))  tmp___31 ;
  int __attribute__((__visibility__("default")))  tmp___32 ;
  timelib_sll tmp___33 ;
  int __attribute__((__visibility__("default")))  tmp___34 ;
  int tmp___35 ;
  int __attribute__((__visibility__("default")))  tmp___36 ;
  int __attribute__((__visibility__("default")))  tmp___37 ;
  long long tmp___38 ;
  char const   *tmp___39 ;
  int __attribute__((__visibility__("default")))  tmp___40 ;
  char const   *tmp___41 ;
  int __attribute__((__visibility__("default")))  tmp___42 ;
  char const   *tmp___43 ;
  int __attribute__((__visibility__("default")))  tmp___44 ;
  int retval ;
  int __attribute__((__visibility__("default")))  tmp___45 ;
  int tmp___46 ;
  int __attribute__((__visibility__("default")))  tmp___47 ;
  int __attribute__((__visibility__("default")))  tmp___48 ;
  int tmp___49 ;
  int __attribute__((__visibility__("default")))  tmp___50 ;
  int __attribute__((__visibility__("default")))  tmp___51 ;
  int __attribute__((__visibility__("default")))  tmp___52 ;
  int __attribute__((__visibility__("default")))  tmp___53 ;
  double tmp___54 ;
  int __attribute__((__visibility__("default")))  tmp___55 ;
  unsigned int tmp___56 ;
  int __attribute__((__visibility__("default")))  tmp___57 ;
  int tmp___58 ;
  int tmp___59 ;
  char const   *tmp___60 ;
  int tmp___61 ;
  int tmp___62 ;
  int tmp___63 ;
  int tmp___64 ;
  int __attribute__((__visibility__("default")))  tmp___65 ;
  char const   *tmp___66 ;
  int __attribute__((__visibility__("default")))  tmp___67 ;
  int __attribute__((__visibility__("default")))  tmp___68 ;
  int __attribute__((__visibility__("default")))  tmp___69 ;
  int __attribute__((__visibility__("default")))  tmp___70 ;
  int tmp___71 ;
  int tmp___72 ;
  int tmp___73 ;
  int __attribute__((__visibility__("default")))  tmp___74 ;
  int32_t tmp___75 ;
  int __attribute__((__visibility__("default")))  tmp___76 ;
  int tmp___77 ;
  int tmp___78 ;
  int tmp___79 ;
  int tmp___80 ;
  int tmp___81 ;
  int tmp___82 ;
  int __attribute__((__visibility__("default")))  tmp___83 ;
  int tmp___84 ;
  int tmp___85 ;
  int tmp___86 ;
  int tmp___87 ;
  int tmp___88 ;
  int tmp___89 ;
  char *tmp___90 ;
  int __attribute__((__visibility__("default")))  tmp___91 ;
  int __attribute__((__visibility__("default")))  tmp___92 ;
  register size_t __nl ;
  smart_str *__dest ;
  void *tmp___93 ;
  void __attribute__((__visibility__("default")))  *tmp___94 ;
  void *tmp___95 ;
  void __attribute__((__visibility__("default")))  *tmp___96 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1621] == 0) {
    {
    fprintf(_coverage_fout, "1621\n");
    fflush(_coverage_fout);
    ___coverage_array[1621] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string.c = (char *)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1622] == 0) {
    {
    fprintf(_coverage_fout, "1622\n");
    fflush(_coverage_fout);
    ___coverage_array[1622] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string.len = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1623] == 0) {
    {
    fprintf(_coverage_fout, "1623\n");
    fflush(_coverage_fout);
    ___coverage_array[1623] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string.a = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1624] == 0) {
    {
    fprintf(_coverage_fout, "1624\n");
    fflush(_coverage_fout);
    ___coverage_array[1624] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  offset = (timelib_time_offset *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1625] == 0) {
    {
    fprintf(_coverage_fout, "1625\n");
    fflush(_coverage_fout);
    ___coverage_array[1625] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! format_len) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1376] == 0) {
      {
      fprintf(_coverage_fout, "1376\n");
      fflush(_coverage_fout);
      ___coverage_array[1376] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = _estrdup("");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1377] == 0) {
      {
      fprintf(_coverage_fout, "1377\n");
      fflush(_coverage_fout);
      ___coverage_array[1377] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1378] == 0) {
      {
      fprintf(_coverage_fout, "1378\n");
      fflush(_coverage_fout);
      ___coverage_array[1378] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1626] == 0) {
    {
    fprintf(_coverage_fout, "1626\n");
    fflush(_coverage_fout);
    ___coverage_array[1626] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1408] == 0) {
      {
      fprintf(_coverage_fout, "1408\n");
      fflush(_coverage_fout);
      ___coverage_array[1408] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (t->zone_type == 2U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1379] == 0) {
        {
        fprintf(_coverage_fout, "1379\n");
        fflush(_coverage_fout);
        ___coverage_array[1379] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset = timelib_time_offset_ctor();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1380] == 0) {
        {
        fprintf(_coverage_fout, "1380\n");
        fflush(_coverage_fout);
        ___coverage_array[1380] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->offset = (t->z - t->dst * 60) * -60;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1381] == 0) {
        {
        fprintf(_coverage_fout, "1381\n");
        fflush(_coverage_fout);
        ___coverage_array[1381] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->leap_secs = 0U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1382] == 0) {
        {
        fprintf(_coverage_fout, "1382\n");
        fflush(_coverage_fout);
        ___coverage_array[1382] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->is_dst = (unsigned int )t->dst;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1383] == 0) {
        {
        fprintf(_coverage_fout, "1383\n");
        fflush(_coverage_fout);
        ___coverage_array[1383] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = __strdup((char const   *)t->tz_abbr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1384] == 0) {
        {
        fprintf(_coverage_fout, "1384\n");
        fflush(_coverage_fout);
        ___coverage_array[1384] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->abbr = tmp___5;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1407] == 0) {
        {
        fprintf(_coverage_fout, "1407\n");
        fflush(_coverage_fout);
        ___coverage_array[1407] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (t->zone_type == 1U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1396] == 0) {
          {
          fprintf(_coverage_fout, "1396\n");
          fflush(_coverage_fout);
          ___coverage_array[1396] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = timelib_time_offset_ctor();
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1397] == 0) {
          {
          fprintf(_coverage_fout, "1397\n");
          fflush(_coverage_fout);
          ___coverage_array[1397] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->offset = t->z * -60;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1398] == 0) {
          {
          fprintf(_coverage_fout, "1398\n");
          fflush(_coverage_fout);
          ___coverage_array[1398] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->leap_secs = 0U;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1399] == 0) {
          {
          fprintf(_coverage_fout, "1399\n");
          fflush(_coverage_fout);
          ___coverage_array[1399] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->is_dst = 0U;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1400] == 0) {
          {
          fprintf(_coverage_fout, "1400\n");
          fflush(_coverage_fout);
          ___coverage_array[1400] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___6 = malloc(9U);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1401] == 0) {
          {
          fprintf(_coverage_fout, "1401\n");
          fflush(_coverage_fout);
          ___coverage_array[1401] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->abbr = (char *)tmp___6;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1402] == 0) {
          {
          fprintf(_coverage_fout, "1402\n");
          fflush(_coverage_fout);
          ___coverage_array[1402] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (localtime___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1385] == 0) {
            {
            fprintf(_coverage_fout, "1385\n");
            fflush(_coverage_fout);
            ___coverage_array[1385] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___7 = abs((offset->offset % 3600) / 60);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1386] == 0) {
            {
            fprintf(_coverage_fout, "1386\n");
            fflush(_coverage_fout);
            ___coverage_array[1386] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = tmp___7;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1387] == 0) {
            {
            fprintf(_coverage_fout, "1387\n");
            fflush(_coverage_fout);
            ___coverage_array[1387] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = 0;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1403] == 0) {
          {
          fprintf(_coverage_fout, "1403\n");
          fflush(_coverage_fout);
          ___coverage_array[1403] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (localtime___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1388] == 0) {
            {
            fprintf(_coverage_fout, "1388\n");
            fflush(_coverage_fout);
            ___coverage_array[1388] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = abs(offset->offset / 3600);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1389] == 0) {
            {
            fprintf(_coverage_fout, "1389\n");
            fflush(_coverage_fout);
            ___coverage_array[1389] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = tmp___9;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1390] == 0) {
            {
            fprintf(_coverage_fout, "1390\n");
            fflush(_coverage_fout);
            ___coverage_array[1390] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = 0;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1404] == 0) {
          {
          fprintf(_coverage_fout, "1404\n");
          fflush(_coverage_fout);
          ___coverage_array[1404] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (localtime___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1393] == 0) {
            {
            fprintf(_coverage_fout, "1393\n");
            fflush(_coverage_fout);
            ___coverage_array[1393] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (offset->offset < 0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1391] == 0) {
              {
              fprintf(_coverage_fout, "1391\n");
              fflush(_coverage_fout);
              ___coverage_array[1391] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___11 = '-';
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1392] == 0) {
              {
              fprintf(_coverage_fout, "1392\n");
              fflush(_coverage_fout);
              ___coverage_array[1392] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___11 = '+';
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1394] == 0) {
            {
            fprintf(_coverage_fout, "1394\n");
            fflush(_coverage_fout);
            ___coverage_array[1394] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___12 = tmp___11;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1395] == 0) {
            {
            fprintf(_coverage_fout, "1395\n");
            fflush(_coverage_fout);
            ___coverage_array[1395] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___12 = '+';
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1405] == 0) {
          {
          fprintf(_coverage_fout, "1405\n");
          fflush(_coverage_fout);
          ___coverage_array[1405] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ap_php_snprintf(offset->abbr, 9U, "GMT%c%02d%02d", tmp___12, tmp___10,
                        tmp___8);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1406] == 0) {
          {
          fprintf(_coverage_fout, "1406\n");
          fflush(_coverage_fout);
          ___coverage_array[1406] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = timelib_get_time_zone_info(t->sse, t->tz_info);
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1409] == 0) {
      {
      fprintf(_coverage_fout, "1409\n");
      fflush(_coverage_fout);
      ___coverage_array[1409] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1627] == 0) {
    {
    fprintf(_coverage_fout, "1627\n");
    fflush(_coverage_fout);
    ___coverage_array[1627] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_isoweek_from_date(t->y, t->m, t->d, & isoweek, & isoyear);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1628] == 0) {
    {
    fprintf(_coverage_fout, "1628\n");
    fflush(_coverage_fout);
    ___coverage_array[1628] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  i = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1629] == 0) {
    {
    fprintf(_coverage_fout, "1629\n");
    fflush(_coverage_fout);
    ___coverage_array[1629] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1612] == 0) {
      {
      fprintf(_coverage_fout, "1612\n");
      fflush(_coverage_fout);
      ___coverage_array[1612] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (i < format_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1410] == 0) {
        {
        fprintf(_coverage_fout, "1410\n");
        fflush(_coverage_fout);
        ___coverage_array[1410] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1613] == 0) {
      {
      fprintf(_coverage_fout, "1613\n");
      fflush(_coverage_fout);
      ___coverage_array[1613] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    rfc_colon = 0;
    switch ((int )*(format + i)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1486] == 0) {
      {
      fprintf(_coverage_fout, "1486\n");
      fflush(_coverage_fout);
      ___coverage_array[1486] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 100: 
    tmp___13 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1487] == 0) {
      {
      fprintf(_coverage_fout, "1487\n");
      fflush(_coverage_fout);
      ___coverage_array[1487] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___13;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1488] == 0) {
      {
      fprintf(_coverage_fout, "1488\n");
      fflush(_coverage_fout);
      ___coverage_array[1488] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 68: 
    tmp___14 = php_date_short_day_name(t->y, t->m, t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1489] == 0) {
      {
      fprintf(_coverage_fout, "1489\n");
      fflush(_coverage_fout);
      ___coverage_array[1489] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___15 = ap_php_slprintf(buffer, 32U, "%s", tmp___14);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1490] == 0) {
      {
      fprintf(_coverage_fout, "1490\n");
      fflush(_coverage_fout);
      ___coverage_array[1490] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___15;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1491] == 0) {
      {
      fprintf(_coverage_fout, "1491\n");
      fflush(_coverage_fout);
      ___coverage_array[1491] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 106: 
    tmp___16 = ap_php_slprintf(buffer, 32U, "%d", (int )t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1492] == 0) {
      {
      fprintf(_coverage_fout, "1492\n");
      fflush(_coverage_fout);
      ___coverage_array[1492] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___16;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1493] == 0) {
      {
      fprintf(_coverage_fout, "1493\n");
      fflush(_coverage_fout);
      ___coverage_array[1493] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 108: 
    tmp___17 = php_date_full_day_name(t->y, t->m, t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1494] == 0) {
      {
      fprintf(_coverage_fout, "1494\n");
      fflush(_coverage_fout);
      ___coverage_array[1494] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___18 = ap_php_slprintf(buffer, 32U, "%s", tmp___17);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1495] == 0) {
      {
      fprintf(_coverage_fout, "1495\n");
      fflush(_coverage_fout);
      ___coverage_array[1495] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___18;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1496] == 0) {
      {
      fprintf(_coverage_fout, "1496\n");
      fflush(_coverage_fout);
      ___coverage_array[1496] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 83: 
    tmp___19 = english_suffix(t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1497] == 0) {
      {
      fprintf(_coverage_fout, "1497\n");
      fflush(_coverage_fout);
      ___coverage_array[1497] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___20 = ap_php_slprintf(buffer, 32U, "%s", tmp___19);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1498] == 0) {
      {
      fprintf(_coverage_fout, "1498\n");
      fflush(_coverage_fout);
      ___coverage_array[1498] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___20;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1499] == 0) {
      {
      fprintf(_coverage_fout, "1499\n");
      fflush(_coverage_fout);
      ___coverage_array[1499] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 119: 
    tmp___21 = timelib_day_of_week(t->y, t->m, t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1500] == 0) {
      {
      fprintf(_coverage_fout, "1500\n");
      fflush(_coverage_fout);
      ___coverage_array[1500] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___22 = ap_php_slprintf(buffer, 32U, "%d", (int )tmp___21);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1501] == 0) {
      {
      fprintf(_coverage_fout, "1501\n");
      fflush(_coverage_fout);
      ___coverage_array[1501] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___22;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1502] == 0) {
      {
      fprintf(_coverage_fout, "1502\n");
      fflush(_coverage_fout);
      ___coverage_array[1502] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 78: 
    tmp___23 = timelib_iso_day_of_week(t->y, t->m, t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1503] == 0) {
      {
      fprintf(_coverage_fout, "1503\n");
      fflush(_coverage_fout);
      ___coverage_array[1503] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___24 = ap_php_slprintf(buffer, 32U, "%d", (int )tmp___23);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1504] == 0) {
      {
      fprintf(_coverage_fout, "1504\n");
      fflush(_coverage_fout);
      ___coverage_array[1504] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___24;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1505] == 0) {
      {
      fprintf(_coverage_fout, "1505\n");
      fflush(_coverage_fout);
      ___coverage_array[1505] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 122: 
    tmp___25 = timelib_day_of_year(t->y, t->m, t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1506] == 0) {
      {
      fprintf(_coverage_fout, "1506\n");
      fflush(_coverage_fout);
      ___coverage_array[1506] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___26 = ap_php_slprintf(buffer, 32U, "%d", (int )tmp___25);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1507] == 0) {
      {
      fprintf(_coverage_fout, "1507\n");
      fflush(_coverage_fout);
      ___coverage_array[1507] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___26;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1508] == 0) {
      {
      fprintf(_coverage_fout, "1508\n");
      fflush(_coverage_fout);
      ___coverage_array[1508] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 87: 
    tmp___27 = ap_php_slprintf(buffer, 32U, "%02d", (int )isoweek);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1509] == 0) {
      {
      fprintf(_coverage_fout, "1509\n");
      fflush(_coverage_fout);
      ___coverage_array[1509] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___27;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1510] == 0) {
      {
      fprintf(_coverage_fout, "1510\n");
      fflush(_coverage_fout);
      ___coverage_array[1510] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 111: 
    tmp___28 = ap_php_slprintf(buffer, 32U, "%d", (int )isoyear);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1511] == 0) {
      {
      fprintf(_coverage_fout, "1511\n");
      fflush(_coverage_fout);
      ___coverage_array[1511] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___28;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1512] == 0) {
      {
      fprintf(_coverage_fout, "1512\n");
      fflush(_coverage_fout);
      ___coverage_array[1512] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 70: 
    tmp___29 = ap_php_slprintf(buffer, 32U, "%s", mon_full_names[t->m - 1LL]);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1513] == 0) {
      {
      fprintf(_coverage_fout, "1513\n");
      fflush(_coverage_fout);
      ___coverage_array[1513] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___29;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1514] == 0) {
      {
      fprintf(_coverage_fout, "1514\n");
      fflush(_coverage_fout);
      ___coverage_array[1514] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 109: 
    tmp___30 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->m);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1515] == 0) {
      {
      fprintf(_coverage_fout, "1515\n");
      fflush(_coverage_fout);
      ___coverage_array[1515] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___30;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1516] == 0) {
      {
      fprintf(_coverage_fout, "1516\n");
      fflush(_coverage_fout);
      ___coverage_array[1516] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 77: 
    tmp___31 = ap_php_slprintf(buffer, 32U, "%s", mon_short_names[t->m - 1LL]);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1517] == 0) {
      {
      fprintf(_coverage_fout, "1517\n");
      fflush(_coverage_fout);
      ___coverage_array[1517] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___31;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1518] == 0) {
      {
      fprintf(_coverage_fout, "1518\n");
      fflush(_coverage_fout);
      ___coverage_array[1518] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 110: 
    tmp___32 = ap_php_slprintf(buffer, 32U, "%d", (int )t->m);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1519] == 0) {
      {
      fprintf(_coverage_fout, "1519\n");
      fflush(_coverage_fout);
      ___coverage_array[1519] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___32;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1520] == 0) {
      {
      fprintf(_coverage_fout, "1520\n");
      fflush(_coverage_fout);
      ___coverage_array[1520] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 116: 
    tmp___33 = timelib_days_in_month(t->y, t->m);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1521] == 0) {
      {
      fprintf(_coverage_fout, "1521\n");
      fflush(_coverage_fout);
      ___coverage_array[1521] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___34 = ap_php_slprintf(buffer, 32U, "%d", (int )tmp___33);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1522] == 0) {
      {
      fprintf(_coverage_fout, "1522\n");
      fflush(_coverage_fout);
      ___coverage_array[1522] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___34;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1523] == 0) {
      {
      fprintf(_coverage_fout, "1523\n");
      fflush(_coverage_fout);
      ___coverage_array[1523] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 76: 
    if ((int )t->y % 4 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1415] == 0) {
        {
        fprintf(_coverage_fout, "1415\n");
        fflush(_coverage_fout);
        ___coverage_array[1415] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )t->y % 100 != 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1411] == 0) {
          {
          fprintf(_coverage_fout, "1411\n");
          fflush(_coverage_fout);
          ___coverage_array[1411] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___35 = 1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1414] == 0) {
          {
          fprintf(_coverage_fout, "1414\n");
          fflush(_coverage_fout);
          ___coverage_array[1414] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int )t->y % 400 == 0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1412] == 0) {
            {
            fprintf(_coverage_fout, "1412\n");
            fflush(_coverage_fout);
            ___coverage_array[1412] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___35 = 1;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1413] == 0) {
            {
            fprintf(_coverage_fout, "1413\n");
            fflush(_coverage_fout);
            ___coverage_array[1413] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___35 = 0;
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1416] == 0) {
        {
        fprintf(_coverage_fout, "1416\n");
        fflush(_coverage_fout);
        ___coverage_array[1416] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___35 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1524] == 0) {
      {
      fprintf(_coverage_fout, "1524\n");
      fflush(_coverage_fout);
      ___coverage_array[1524] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___36 = ap_php_slprintf(buffer, 32U, "%d", tmp___35);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1525] == 0) {
      {
      fprintf(_coverage_fout, "1525\n");
      fflush(_coverage_fout);
      ___coverage_array[1525] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___36;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1526] == 0) {
      {
      fprintf(_coverage_fout, "1526\n");
      fflush(_coverage_fout);
      ___coverage_array[1526] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 121: 
    tmp___37 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->y % 100);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1527] == 0) {
      {
      fprintf(_coverage_fout, "1527\n");
      fflush(_coverage_fout);
      ___coverage_array[1527] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___37;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1528] == 0) {
      {
      fprintf(_coverage_fout, "1528\n");
      fflush(_coverage_fout);
      ___coverage_array[1528] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 89: 
    tmp___38 = php_date_llabs(t->y);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1529] == 0) {
      {
      fprintf(_coverage_fout, "1529\n");
      fflush(_coverage_fout);
      ___coverage_array[1529] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (t->y < 0LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1417] == 0) {
        {
        fprintf(_coverage_fout, "1417\n");
        fflush(_coverage_fout);
        ___coverage_array[1417] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___39 = "-";
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1418] == 0) {
        {
        fprintf(_coverage_fout, "1418\n");
        fflush(_coverage_fout);
        ___coverage_array[1418] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___39 = "";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1530] == 0) {
      {
      fprintf(_coverage_fout, "1530\n");
      fflush(_coverage_fout);
      ___coverage_array[1530] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___40 = ap_php_slprintf(buffer, 32U, "%s%04lld", tmp___39, tmp___38);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1531] == 0) {
      {
      fprintf(_coverage_fout, "1531\n");
      fflush(_coverage_fout);
      ___coverage_array[1531] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___40;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1532] == 0) {
      {
      fprintf(_coverage_fout, "1532\n");
      fflush(_coverage_fout);
      ___coverage_array[1532] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 97: 
    if (t->h >= 12LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1419] == 0) {
        {
        fprintf(_coverage_fout, "1419\n");
        fflush(_coverage_fout);
        ___coverage_array[1419] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___41 = "pm";
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1420] == 0) {
        {
        fprintf(_coverage_fout, "1420\n");
        fflush(_coverage_fout);
        ___coverage_array[1420] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___41 = "am";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1533] == 0) {
      {
      fprintf(_coverage_fout, "1533\n");
      fflush(_coverage_fout);
      ___coverage_array[1533] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___42 = ap_php_slprintf(buffer, 32U, "%s", tmp___41);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1534] == 0) {
      {
      fprintf(_coverage_fout, "1534\n");
      fflush(_coverage_fout);
      ___coverage_array[1534] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___42;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1535] == 0) {
      {
      fprintf(_coverage_fout, "1535\n");
      fflush(_coverage_fout);
      ___coverage_array[1535] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 65: 
    if (t->h >= 12LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1421] == 0) {
        {
        fprintf(_coverage_fout, "1421\n");
        fflush(_coverage_fout);
        ___coverage_array[1421] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___43 = "PM";
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1422] == 0) {
        {
        fprintf(_coverage_fout, "1422\n");
        fflush(_coverage_fout);
        ___coverage_array[1422] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___43 = "AM";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1536] == 0) {
      {
      fprintf(_coverage_fout, "1536\n");
      fflush(_coverage_fout);
      ___coverage_array[1536] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___44 = ap_php_slprintf(buffer, 32U, "%s", tmp___43);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1537] == 0) {
      {
      fprintf(_coverage_fout, "1537\n");
      fflush(_coverage_fout);
      ___coverage_array[1537] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___44;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1538] == 0) {
      {
      fprintf(_coverage_fout, "1538\n");
      fflush(_coverage_fout);
      ___coverage_array[1538] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 66: 
    retval = (int )((((long )t->sse - ((long )t->sse - ((long )t->sse % 86400L + 3600L))) * 10L) / 864L);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1539] == 0) {
      {
      fprintf(_coverage_fout, "1539\n");
      fflush(_coverage_fout);
      ___coverage_array[1539] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1424] == 0) {
        {
        fprintf(_coverage_fout, "1424\n");
        fflush(_coverage_fout);
        ___coverage_array[1424] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (retval < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1423] == 0) {
          {
          fprintf(_coverage_fout, "1423\n");
          fflush(_coverage_fout);
          ___coverage_array[1423] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1425] == 0) {
        {
        fprintf(_coverage_fout, "1425\n");
        fflush(_coverage_fout);
        ___coverage_array[1425] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      retval += 1000;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1540] == 0) {
      {
      fprintf(_coverage_fout, "1540\n");
      fflush(_coverage_fout);
      ___coverage_array[1540] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval %= 1000;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1541] == 0) {
      {
      fprintf(_coverage_fout, "1541\n");
      fflush(_coverage_fout);
      ___coverage_array[1541] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___45 = ap_php_slprintf(buffer, 32U, "%03d", retval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1542] == 0) {
      {
      fprintf(_coverage_fout, "1542\n");
      fflush(_coverage_fout);
      ___coverage_array[1542] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___45;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1543] == 0) {
      {
      fprintf(_coverage_fout, "1543\n");
      fflush(_coverage_fout);
      ___coverage_array[1543] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 103: 
    if (t->h % 12LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1426] == 0) {
        {
        fprintf(_coverage_fout, "1426\n");
        fflush(_coverage_fout);
        ___coverage_array[1426] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___46 = (int )t->h % 12;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1427] == 0) {
        {
        fprintf(_coverage_fout, "1427\n");
        fflush(_coverage_fout);
        ___coverage_array[1427] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___46 = 12;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1544] == 0) {
      {
      fprintf(_coverage_fout, "1544\n");
      fflush(_coverage_fout);
      ___coverage_array[1544] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___47 = ap_php_slprintf(buffer, 32U, "%d", tmp___46);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1545] == 0) {
      {
      fprintf(_coverage_fout, "1545\n");
      fflush(_coverage_fout);
      ___coverage_array[1545] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___47;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1546] == 0) {
      {
      fprintf(_coverage_fout, "1546\n");
      fflush(_coverage_fout);
      ___coverage_array[1546] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 71: 
    tmp___48 = ap_php_slprintf(buffer, 32U, "%d", (int )t->h);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1547] == 0) {
      {
      fprintf(_coverage_fout, "1547\n");
      fflush(_coverage_fout);
      ___coverage_array[1547] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___48;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1548] == 0) {
      {
      fprintf(_coverage_fout, "1548\n");
      fflush(_coverage_fout);
      ___coverage_array[1548] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 104: 
    if (t->h % 12LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1428] == 0) {
        {
        fprintf(_coverage_fout, "1428\n");
        fflush(_coverage_fout);
        ___coverage_array[1428] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___49 = (int )t->h % 12;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1429] == 0) {
        {
        fprintf(_coverage_fout, "1429\n");
        fflush(_coverage_fout);
        ___coverage_array[1429] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___49 = 12;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1549] == 0) {
      {
      fprintf(_coverage_fout, "1549\n");
      fflush(_coverage_fout);
      ___coverage_array[1549] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___50 = ap_php_slprintf(buffer, 32U, "%02d", tmp___49);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1550] == 0) {
      {
      fprintf(_coverage_fout, "1550\n");
      fflush(_coverage_fout);
      ___coverage_array[1550] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___50;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1551] == 0) {
      {
      fprintf(_coverage_fout, "1551\n");
      fflush(_coverage_fout);
      ___coverage_array[1551] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 72: 
    tmp___51 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->h);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1552] == 0) {
      {
      fprintf(_coverage_fout, "1552\n");
      fflush(_coverage_fout);
      ___coverage_array[1552] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___51;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1553] == 0) {
      {
      fprintf(_coverage_fout, "1553\n");
      fflush(_coverage_fout);
      ___coverage_array[1553] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 105: 
    tmp___52 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->i);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1554] == 0) {
      {
      fprintf(_coverage_fout, "1554\n");
      fflush(_coverage_fout);
      ___coverage_array[1554] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___52;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1555] == 0) {
      {
      fprintf(_coverage_fout, "1555\n");
      fflush(_coverage_fout);
      ___coverage_array[1555] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 115: 
    tmp___53 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1556] == 0) {
      {
      fprintf(_coverage_fout, "1556\n");
      fflush(_coverage_fout);
      ___coverage_array[1556] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___53;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1557] == 0) {
      {
      fprintf(_coverage_fout, "1557\n");
      fflush(_coverage_fout);
      ___coverage_array[1557] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 117: 
    tmp___54 = floor(t->f * (double )1000000);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1558] == 0) {
      {
      fprintf(_coverage_fout, "1558\n");
      fflush(_coverage_fout);
      ___coverage_array[1558] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___55 = ap_php_slprintf(buffer, 32U, "%06d", (int )tmp___54);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1559] == 0) {
      {
      fprintf(_coverage_fout, "1559\n");
      fflush(_coverage_fout);
      ___coverage_array[1559] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___55;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1560] == 0) {
      {
      fprintf(_coverage_fout, "1560\n");
      fflush(_coverage_fout);
      ___coverage_array[1560] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 73: 
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1430] == 0) {
        {
        fprintf(_coverage_fout, "1430\n");
        fflush(_coverage_fout);
        ___coverage_array[1430] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___56 = offset->is_dst;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1431] == 0) {
        {
        fprintf(_coverage_fout, "1431\n");
        fflush(_coverage_fout);
        ___coverage_array[1431] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___56 = 0U;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1561] == 0) {
      {
      fprintf(_coverage_fout, "1561\n");
      fflush(_coverage_fout);
      ___coverage_array[1561] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___57 = ap_php_slprintf(buffer, 32U, "%d", tmp___56);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1562] == 0) {
      {
      fprintf(_coverage_fout, "1562\n");
      fflush(_coverage_fout);
      ___coverage_array[1562] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___57;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1563] == 0) {
      {
      fprintf(_coverage_fout, "1563\n");
      fflush(_coverage_fout);
      ___coverage_array[1563] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 80: 
    rfc_colon = 1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1564] == 0) {
      {
      fprintf(_coverage_fout, "1564\n");
      fflush(_coverage_fout);
      ___coverage_array[1564] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 79: 
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1432] == 0) {
        {
        fprintf(_coverage_fout, "1432\n");
        fflush(_coverage_fout);
        ___coverage_array[1432] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___58 = abs((offset->offset % 3600) / 60);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1433] == 0) {
        {
        fprintf(_coverage_fout, "1433\n");
        fflush(_coverage_fout);
        ___coverage_array[1433] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___59 = tmp___58;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1434] == 0) {
        {
        fprintf(_coverage_fout, "1434\n");
        fflush(_coverage_fout);
        ___coverage_array[1434] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___59 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1565] == 0) {
      {
      fprintf(_coverage_fout, "1565\n");
      fflush(_coverage_fout);
      ___coverage_array[1565] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (rfc_colon) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1435] == 0) {
        {
        fprintf(_coverage_fout, "1435\n");
        fflush(_coverage_fout);
        ___coverage_array[1435] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___60 = ":";
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1436] == 0) {
        {
        fprintf(_coverage_fout, "1436\n");
        fflush(_coverage_fout);
        ___coverage_array[1436] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___60 = "";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1566] == 0) {
      {
      fprintf(_coverage_fout, "1566\n");
      fflush(_coverage_fout);
      ___coverage_array[1566] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1437] == 0) {
        {
        fprintf(_coverage_fout, "1437\n");
        fflush(_coverage_fout);
        ___coverage_array[1437] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___61 = abs(offset->offset / 3600);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1438] == 0) {
        {
        fprintf(_coverage_fout, "1438\n");
        fflush(_coverage_fout);
        ___coverage_array[1438] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___62 = tmp___61;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1439] == 0) {
        {
        fprintf(_coverage_fout, "1439\n");
        fflush(_coverage_fout);
        ___coverage_array[1439] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___62 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1567] == 0) {
      {
      fprintf(_coverage_fout, "1567\n");
      fflush(_coverage_fout);
      ___coverage_array[1567] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1442] == 0) {
        {
        fprintf(_coverage_fout, "1442\n");
        fflush(_coverage_fout);
        ___coverage_array[1442] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (offset->offset < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1440] == 0) {
          {
          fprintf(_coverage_fout, "1440\n");
          fflush(_coverage_fout);
          ___coverage_array[1440] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___63 = '-';
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1441] == 0) {
          {
          fprintf(_coverage_fout, "1441\n");
          fflush(_coverage_fout);
          ___coverage_array[1441] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___63 = '+';
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1443] == 0) {
        {
        fprintf(_coverage_fout, "1443\n");
        fflush(_coverage_fout);
        ___coverage_array[1443] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___64 = tmp___63;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1444] == 0) {
        {
        fprintf(_coverage_fout, "1444\n");
        fflush(_coverage_fout);
        ___coverage_array[1444] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___64 = '+';
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1568] == 0) {
      {
      fprintf(_coverage_fout, "1568\n");
      fflush(_coverage_fout);
      ___coverage_array[1568] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___65 = ap_php_slprintf(buffer, 32U, "%c%02d%s%02d", tmp___64, tmp___62,
                               tmp___60, tmp___59);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1569] == 0) {
      {
      fprintf(_coverage_fout, "1569\n");
      fflush(_coverage_fout);
      ___coverage_array[1569] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___65;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1570] == 0) {
      {
      fprintf(_coverage_fout, "1570\n");
      fflush(_coverage_fout);
      ___coverage_array[1570] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 84: 
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1445] == 0) {
        {
        fprintf(_coverage_fout, "1445\n");
        fflush(_coverage_fout);
        ___coverage_array[1445] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___66 = (char const   *)offset->abbr;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1446] == 0) {
        {
        fprintf(_coverage_fout, "1446\n");
        fflush(_coverage_fout);
        ___coverage_array[1446] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___66 = "GMT";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1571] == 0) {
      {
      fprintf(_coverage_fout, "1571\n");
      fflush(_coverage_fout);
      ___coverage_array[1571] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___67 = ap_php_slprintf(buffer, 32U, "%s", tmp___66);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1572] == 0) {
      {
      fprintf(_coverage_fout, "1572\n");
      fflush(_coverage_fout);
      ___coverage_array[1572] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___67;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1573] == 0) {
      {
      fprintf(_coverage_fout, "1573\n");
      fflush(_coverage_fout);
      ___coverage_array[1573] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 101: 
    if (! localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1447] == 0) {
        {
        fprintf(_coverage_fout, "1447\n");
        fflush(_coverage_fout);
        ___coverage_array[1447] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___68 = ap_php_slprintf(buffer, 32U, "%s", "UTC");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1448] == 0) {
        {
        fprintf(_coverage_fout, "1448\n");
        fflush(_coverage_fout);
        ___coverage_array[1448] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___68;
    } else {
      switch ((int )t->zone_type) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1451] == 0) {
        {
        fprintf(_coverage_fout, "1451\n");
        fflush(_coverage_fout);
        ___coverage_array[1451] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 3: 
      tmp___69 = ap_php_slprintf(buffer, 32U, "%s", (t->tz_info)->name);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1452] == 0) {
        {
        fprintf(_coverage_fout, "1452\n");
        fflush(_coverage_fout);
        ___coverage_array[1452] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___69;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1453] == 0) {
        {
        fprintf(_coverage_fout, "1453\n");
        fflush(_coverage_fout);
        ___coverage_array[1453] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 2: 
      tmp___70 = ap_php_slprintf(buffer, 32U, "%s", offset->abbr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1454] == 0) {
        {
        fprintf(_coverage_fout, "1454\n");
        fflush(_coverage_fout);
        ___coverage_array[1454] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___70;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1455] == 0) {
        {
        fprintf(_coverage_fout, "1455\n");
        fflush(_coverage_fout);
        ___coverage_array[1455] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 1: 
      tmp___71 = abs((offset->offset % 3600) / 60);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1456] == 0) {
        {
        fprintf(_coverage_fout, "1456\n");
        fflush(_coverage_fout);
        ___coverage_array[1456] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___72 = abs(offset->offset / 3600);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1457] == 0) {
        {
        fprintf(_coverage_fout, "1457\n");
        fflush(_coverage_fout);
        ___coverage_array[1457] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (offset->offset < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1449] == 0) {
          {
          fprintf(_coverage_fout, "1449\n");
          fflush(_coverage_fout);
          ___coverage_array[1449] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___73 = '-';
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1450] == 0) {
          {
          fprintf(_coverage_fout, "1450\n");
          fflush(_coverage_fout);
          ___coverage_array[1450] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___73 = '+';
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1458] == 0) {
        {
        fprintf(_coverage_fout, "1458\n");
        fflush(_coverage_fout);
        ___coverage_array[1458] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___74 = ap_php_slprintf(buffer, 32U, "%c%02d:%02d", tmp___73, tmp___72,
                                 tmp___71);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1459] == 0) {
        {
        fprintf(_coverage_fout, "1459\n");
        fflush(_coverage_fout);
        ___coverage_array[1459] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___74;
      break;
      }
    }
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1574] == 0) {
      {
      fprintf(_coverage_fout, "1574\n");
      fflush(_coverage_fout);
      ___coverage_array[1574] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 90: 
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1460] == 0) {
        {
        fprintf(_coverage_fout, "1460\n");
        fflush(_coverage_fout);
        ___coverage_array[1460] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___75 = offset->offset;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1461] == 0) {
        {
        fprintf(_coverage_fout, "1461\n");
        fflush(_coverage_fout);
        ___coverage_array[1461] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___75 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1575] == 0) {
      {
      fprintf(_coverage_fout, "1575\n");
      fflush(_coverage_fout);
      ___coverage_array[1575] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___76 = ap_php_slprintf(buffer, 32U, "%d", tmp___75);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1576] == 0) {
      {
      fprintf(_coverage_fout, "1576\n");
      fflush(_coverage_fout);
      ___coverage_array[1576] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___76;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1577] == 0) {
      {
      fprintf(_coverage_fout, "1577\n");
      fflush(_coverage_fout);
      ___coverage_array[1577] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 99: 
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1462] == 0) {
        {
        fprintf(_coverage_fout, "1462\n");
        fflush(_coverage_fout);
        ___coverage_array[1462] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___77 = abs((offset->offset % 3600) / 60);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1463] == 0) {
        {
        fprintf(_coverage_fout, "1463\n");
        fflush(_coverage_fout);
        ___coverage_array[1463] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___78 = tmp___77;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1464] == 0) {
        {
        fprintf(_coverage_fout, "1464\n");
        fflush(_coverage_fout);
        ___coverage_array[1464] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___78 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1578] == 0) {
      {
      fprintf(_coverage_fout, "1578\n");
      fflush(_coverage_fout);
      ___coverage_array[1578] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1465] == 0) {
        {
        fprintf(_coverage_fout, "1465\n");
        fflush(_coverage_fout);
        ___coverage_array[1465] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___79 = abs(offset->offset / 3600);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1466] == 0) {
        {
        fprintf(_coverage_fout, "1466\n");
        fflush(_coverage_fout);
        ___coverage_array[1466] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___80 = tmp___79;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1467] == 0) {
        {
        fprintf(_coverage_fout, "1467\n");
        fflush(_coverage_fout);
        ___coverage_array[1467] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___80 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1579] == 0) {
      {
      fprintf(_coverage_fout, "1579\n");
      fflush(_coverage_fout);
      ___coverage_array[1579] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1470] == 0) {
        {
        fprintf(_coverage_fout, "1470\n");
        fflush(_coverage_fout);
        ___coverage_array[1470] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (offset->offset < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1468] == 0) {
          {
          fprintf(_coverage_fout, "1468\n");
          fflush(_coverage_fout);
          ___coverage_array[1468] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___81 = '-';
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1469] == 0) {
          {
          fprintf(_coverage_fout, "1469\n");
          fflush(_coverage_fout);
          ___coverage_array[1469] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___81 = '+';
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1471] == 0) {
        {
        fprintf(_coverage_fout, "1471\n");
        fflush(_coverage_fout);
        ___coverage_array[1471] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___82 = tmp___81;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1472] == 0) {
        {
        fprintf(_coverage_fout, "1472\n");
        fflush(_coverage_fout);
        ___coverage_array[1472] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___82 = '+';
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1580] == 0) {
      {
      fprintf(_coverage_fout, "1580\n");
      fflush(_coverage_fout);
      ___coverage_array[1580] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___83 = ap_php_slprintf(buffer, 96U,
                               "%04d-%02d-%02dT%02d:%02d:%02d%c%02d:%02d",
                               (int )t->y, (int )t->m, (int )t->d, (int )t->h,
                               (int )t->i, (int )t->s, tmp___82, tmp___80,
                               tmp___78);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1581] == 0) {
      {
      fprintf(_coverage_fout, "1581\n");
      fflush(_coverage_fout);
      ___coverage_array[1581] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___83;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1582] == 0) {
      {
      fprintf(_coverage_fout, "1582\n");
      fflush(_coverage_fout);
      ___coverage_array[1582] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 114: 
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1473] == 0) {
        {
        fprintf(_coverage_fout, "1473\n");
        fflush(_coverage_fout);
        ___coverage_array[1473] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___84 = abs((offset->offset % 3600) / 60);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1474] == 0) {
        {
        fprintf(_coverage_fout, "1474\n");
        fflush(_coverage_fout);
        ___coverage_array[1474] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___85 = tmp___84;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1475] == 0) {
        {
        fprintf(_coverage_fout, "1475\n");
        fflush(_coverage_fout);
        ___coverage_array[1475] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___85 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1583] == 0) {
      {
      fprintf(_coverage_fout, "1583\n");
      fflush(_coverage_fout);
      ___coverage_array[1583] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1476] == 0) {
        {
        fprintf(_coverage_fout, "1476\n");
        fflush(_coverage_fout);
        ___coverage_array[1476] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___86 = abs(offset->offset / 3600);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1477] == 0) {
        {
        fprintf(_coverage_fout, "1477\n");
        fflush(_coverage_fout);
        ___coverage_array[1477] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___87 = tmp___86;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1478] == 0) {
        {
        fprintf(_coverage_fout, "1478\n");
        fflush(_coverage_fout);
        ___coverage_array[1478] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___87 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1584] == 0) {
      {
      fprintf(_coverage_fout, "1584\n");
      fflush(_coverage_fout);
      ___coverage_array[1584] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (localtime___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1481] == 0) {
        {
        fprintf(_coverage_fout, "1481\n");
        fflush(_coverage_fout);
        ___coverage_array[1481] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (offset->offset < 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1479] == 0) {
          {
          fprintf(_coverage_fout, "1479\n");
          fflush(_coverage_fout);
          ___coverage_array[1479] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___88 = '-';
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1480] == 0) {
          {
          fprintf(_coverage_fout, "1480\n");
          fflush(_coverage_fout);
          ___coverage_array[1480] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___88 = '+';
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1482] == 0) {
        {
        fprintf(_coverage_fout, "1482\n");
        fflush(_coverage_fout);
        ___coverage_array[1482] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___89 = tmp___88;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1483] == 0) {
        {
        fprintf(_coverage_fout, "1483\n");
        fflush(_coverage_fout);
        ___coverage_array[1483] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___89 = '+';
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1585] == 0) {
      {
      fprintf(_coverage_fout, "1585\n");
      fflush(_coverage_fout);
      ___coverage_array[1585] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___90 = php_date_short_day_name(t->y, t->m, t->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1586] == 0) {
      {
      fprintf(_coverage_fout, "1586\n");
      fflush(_coverage_fout);
      ___coverage_array[1586] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___91 = ap_php_slprintf(buffer, 96U,
                               "%3s, %02d %3s %04d %02d:%02d:%02d %c%02d%02d",
                               tmp___90, (int )t->d,
                               mon_short_names[t->m - 1LL], (int )t->y,
                               (int )t->h, (int )t->i, (int )t->s, tmp___89,
                               tmp___87, tmp___85);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1587] == 0) {
      {
      fprintf(_coverage_fout, "1587\n");
      fflush(_coverage_fout);
      ___coverage_array[1587] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___91;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1588] == 0) {
      {
      fprintf(_coverage_fout, "1588\n");
      fflush(_coverage_fout);
      ___coverage_array[1588] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 85: 
    tmp___92 = ap_php_slprintf(buffer, 32U, "%lld", t->sse);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1589] == 0) {
      {
      fprintf(_coverage_fout, "1589\n");
      fflush(_coverage_fout);
      ___coverage_array[1589] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = (int )tmp___92;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1590] == 0) {
      {
      fprintf(_coverage_fout, "1590\n");
      fflush(_coverage_fout);
      ___coverage_array[1590] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 92: 
    if (i < format_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1484] == 0) {
        {
        fprintf(_coverage_fout, "1484\n");
        fflush(_coverage_fout);
        ___coverage_array[1484] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      i ++;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1485] == 0) {
        {
        fprintf(_coverage_fout, "1485\n");
        fflush(_coverage_fout);
        ___coverage_array[1485] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1591] == 0) {
      {
      fprintf(_coverage_fout, "1591\n");
      fflush(_coverage_fout);
      ___coverage_array[1591] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    default: 
    buffer[0] = *(format + i);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1592] == 0) {
      {
      fprintf(_coverage_fout, "1592\n");
      fflush(_coverage_fout);
      ___coverage_array[1592] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    buffer[1] = (char )'\000';
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1593] == 0) {
      {
      fprintf(_coverage_fout, "1593\n");
      fflush(_coverage_fout);
      ___coverage_array[1593] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    length = 1;
    break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1614] == 0) {
      {
      fprintf(_coverage_fout, "1614\n");
      fflush(_coverage_fout);
      ___coverage_array[1614] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1608] == 0) {
        {
        fprintf(_coverage_fout, "1608\n");
        fflush(_coverage_fout);
        ___coverage_array[1608] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __dest = & string;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1609] == 0) {
        {
        fprintf(_coverage_fout, "1609\n");
        fflush(_coverage_fout);
        ___coverage_array[1609] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1607] == 0) {
          {
          fprintf(_coverage_fout, "1607\n");
          fflush(_coverage_fout);
          ___coverage_array[1607] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! __dest->c) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1596] == 0) {
            {
            fprintf(_coverage_fout, "1596\n");
            fflush(_coverage_fout);
            ___coverage_array[1596] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __dest->len = 0U;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1597] == 0) {
            {
            fprintf(_coverage_fout, "1597\n");
            fflush(_coverage_fout);
            ___coverage_array[1597] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __nl = (unsigned int )length;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1598] == 0) {
            {
            fprintf(_coverage_fout, "1598\n");
            fflush(_coverage_fout);
            ___coverage_array[1598] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (__nl < 78U) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1594] == 0) {
              {
              fprintf(_coverage_fout, "1594\n");
              fflush(_coverage_fout);
              ___coverage_array[1594] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __dest->a = 78U;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1595] == 0) {
              {
              fprintf(_coverage_fout, "1595\n");
              fflush(_coverage_fout);
              ___coverage_array[1595] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __dest->a = __nl + 128U;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1599] == 0) {
            {
            fprintf(_coverage_fout, "1599\n");
            fflush(_coverage_fout);
            ___coverage_array[1599] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___94 = _erealloc((void *)__dest->c, __dest->a + 1U, 0);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1600] == 0) {
            {
            fprintf(_coverage_fout, "1600\n");
            fflush(_coverage_fout);
            ___coverage_array[1600] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __dest->c = (char *)((void *)tmp___94);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1605] == 0) {
            {
            fprintf(_coverage_fout, "1605\n");
            fflush(_coverage_fout);
            ___coverage_array[1605] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __nl = __dest->len + (size_t )length;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1606] == 0) {
            {
            fprintf(_coverage_fout, "1606\n");
            fflush(_coverage_fout);
            ___coverage_array[1606] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (__nl >= __dest->a) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1601] == 0) {
              {
              fprintf(_coverage_fout, "1601\n");
              fflush(_coverage_fout);
              ___coverage_array[1601] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __dest->a = __nl + 128U;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1602] == 0) {
              {
              fprintf(_coverage_fout, "1602\n");
              fflush(_coverage_fout);
              ___coverage_array[1602] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___96 = _erealloc((void *)__dest->c, __dest->a + 1U, 0);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1603] == 0) {
              {
              fprintf(_coverage_fout, "1603\n");
              fflush(_coverage_fout);
              ___coverage_array[1603] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __dest->c = (char *)((void *)tmp___96);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1604] == 0) {
              {
              fprintf(_coverage_fout, "1604\n");
              fflush(_coverage_fout);
              ___coverage_array[1604] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        }
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1610] == 0) {
        {
        fprintf(_coverage_fout, "1610\n");
        fflush(_coverage_fout);
        ___coverage_array[1610] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      memcpy((void */* __restrict  */)(__dest->c + __dest->len),
             (void const   */* __restrict  */)(buffer), (unsigned int )length);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1611] == 0) {
        {
        fprintf(_coverage_fout, "1611\n");
        fflush(_coverage_fout);
        ___coverage_array[1611] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __dest->len = __nl;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1615] == 0) {
      {
      fprintf(_coverage_fout, "1615\n");
      fflush(_coverage_fout);
      ___coverage_array[1615] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1630] == 0) {
    {
    fprintf(_coverage_fout, "1630\n");
    fflush(_coverage_fout);
    ___coverage_array[1630] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1618] == 0) {
      {
      fprintf(_coverage_fout, "1618\n");
      fflush(_coverage_fout);
      ___coverage_array[1618] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (string.c) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1616] == 0) {
        {
        fprintf(_coverage_fout, "1616\n");
        fflush(_coverage_fout);
        ___coverage_array[1616] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *(string.c + string.len) = (char )'\000';
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1617] == 0) {
        {
        fprintf(_coverage_fout, "1617\n");
        fflush(_coverage_fout);
        ___coverage_array[1617] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1631] == 0) {
    {
    fprintf(_coverage_fout, "1631\n");
    fflush(_coverage_fout);
    ___coverage_array[1631] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1619] == 0) {
      {
      fprintf(_coverage_fout, "1619\n");
      fflush(_coverage_fout);
      ___coverage_array[1619] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_offset_dtor(offset);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1620] == 0) {
      {
      fprintf(_coverage_fout, "1620\n");
      fflush(_coverage_fout);
      ___coverage_array[1620] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1632] == 0) {
    {
    fprintf(_coverage_fout, "1632\n");
    fflush(_coverage_fout);
    ___coverage_array[1632] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (string.c);
}
}
static void php_date(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used , int localtime___0 ) 
{ char *format ;
  int format_len ;
  long ts ;
  char *string ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1647] == 0) {
    {
    fprintf(_coverage_fout, "1647\n");
    fflush(_coverage_fout);
    ___coverage_array[1647] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s|l", & format, & format_len, & ts);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1648] == 0) {
    {
    fprintf(_coverage_fout, "1648\n");
    fflush(_coverage_fout);
    ___coverage_array[1648] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1636] == 0) {
      {
      fprintf(_coverage_fout, "1636\n");
      fflush(_coverage_fout);
      ___coverage_array[1636] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1633] == 0) {
        {
        fprintf(_coverage_fout, "1633\n");
        fflush(_coverage_fout);
        ___coverage_array[1633] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1634] == 0) {
        {
        fprintf(_coverage_fout, "1634\n");
        fflush(_coverage_fout);
        ___coverage_array[1634] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1635] == 0) {
        {
        fprintf(_coverage_fout, "1635\n");
        fflush(_coverage_fout);
        ___coverage_array[1635] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1637] == 0) {
      {
      fprintf(_coverage_fout, "1637\n");
      fflush(_coverage_fout);
      ___coverage_array[1637] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1638] == 0) {
      {
      fprintf(_coverage_fout, "1638\n");
      fflush(_coverage_fout);
      ___coverage_array[1638] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1649] == 0) {
    {
    fprintf(_coverage_fout, "1649\n");
    fflush(_coverage_fout);
    ___coverage_array[1649] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ht == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1639] == 0) {
      {
      fprintf(_coverage_fout, "1639\n");
      fflush(_coverage_fout);
      ___coverage_array[1639] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ts = time((time_t *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1640] == 0) {
      {
      fprintf(_coverage_fout, "1640\n");
      fflush(_coverage_fout);
      ___coverage_array[1640] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1650] == 0) {
    {
    fprintf(_coverage_fout, "1650\n");
    fflush(_coverage_fout);
    ___coverage_array[1650] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = php_format_date(format, format_len, ts, localtime___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1651] == 0) {
    {
    fprintf(_coverage_fout, "1651\n");
    fflush(_coverage_fout);
    ___coverage_array[1651] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string = (char *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1652] == 0) {
    {
    fprintf(_coverage_fout, "1652\n");
    fflush(_coverage_fout);
    ___coverage_array[1652] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1641] == 0) {
      {
      fprintf(_coverage_fout, "1641\n");
      fflush(_coverage_fout);
      ___coverage_array[1641] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)string;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1642] == 0) {
      {
      fprintf(_coverage_fout, "1642\n");
      fflush(_coverage_fout);
      ___coverage_array[1642] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1643] == 0) {
      {
      fprintf(_coverage_fout, "1643\n");
      fflush(_coverage_fout);
      ___coverage_array[1643] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1644] == 0) {
      {
      fprintf(_coverage_fout, "1644\n");
      fflush(_coverage_fout);
      ___coverage_array[1644] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.str.len = (int )tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1645] == 0) {
      {
      fprintf(_coverage_fout, "1645\n");
      fflush(_coverage_fout);
      ___coverage_array[1645] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1646] == 0) {
      {
      fprintf(_coverage_fout, "1646\n");
      fflush(_coverage_fout);
      ___coverage_array[1646] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1653] == 0) {
    {
    fprintf(_coverage_fout, "1653\n");
    fflush(_coverage_fout);
    ___coverage_array[1653] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
char __attribute__((__visibility__("default")))  *php_format_date(char *format ,
                                                                  int format_len ,
                                                                  time_t ts ,
                                                                  int localtime___0 ) 
{ timelib_time *t ;
  timelib_tzinfo *tzi ;
  char *string ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1661] == 0) {
    {
    fprintf(_coverage_fout, "1661\n");
    fflush(_coverage_fout);
    ___coverage_array[1661] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1662] == 0) {
    {
    fprintf(_coverage_fout, "1662\n");
    fflush(_coverage_fout);
    ___coverage_array[1662] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1654] == 0) {
      {
      fprintf(_coverage_fout, "1654\n");
      fflush(_coverage_fout);
      ___coverage_array[1654] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = get_timezone_info();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1655] == 0) {
      {
      fprintf(_coverage_fout, "1655\n");
      fflush(_coverage_fout);
      ___coverage_array[1655] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1656] == 0) {
      {
      fprintf(_coverage_fout, "1656\n");
      fflush(_coverage_fout);
      ___coverage_array[1656] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    t->tz_info = tzi;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1657] == 0) {
      {
      fprintf(_coverage_fout, "1657\n");
      fflush(_coverage_fout);
      ___coverage_array[1657] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    t->zone_type = 3U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1658] == 0) {
      {
      fprintf(_coverage_fout, "1658\n");
      fflush(_coverage_fout);
      ___coverage_array[1658] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2local(t, (long long )ts);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1659] == 0) {
      {
      fprintf(_coverage_fout, "1659\n");
      fflush(_coverage_fout);
      ___coverage_array[1659] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)((void *)0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1660] == 0) {
      {
      fprintf(_coverage_fout, "1660\n");
      fflush(_coverage_fout);
      ___coverage_array[1660] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2gmt(t, (long long )ts);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1663] == 0) {
    {
    fprintf(_coverage_fout, "1663\n");
    fflush(_coverage_fout);
    ___coverage_array[1663] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string = date_format(format, format_len, t, localtime___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1664] == 0) {
    {
    fprintf(_coverage_fout, "1664\n");
    fflush(_coverage_fout);
    ___coverage_array[1664] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(t);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1665] == 0) {
    {
    fprintf(_coverage_fout, "1665\n");
    fflush(_coverage_fout);
    ___coverage_array[1665] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((char __attribute__((__visibility__("default")))  *)string);
}
}
int __attribute__((__visibility__("default")))  php_idate(char format ,
                                                          time_t ts ,
                                                          int localtime___0 ) 
{ timelib_time *t ;
  timelib_tzinfo *tzi ;
  int retval ;
  timelib_time_offset *offset ;
  timelib_sll isoweek ;
  timelib_sll isoyear ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp ;
  void *tmp___0 ;
  size_t __len ;
  size_t tmp___1 ;
  char *__retval ;
  void *tmp___2 ;
  void *tmp___3 ;
  char *tmp___4 ;
  char *tmp___5 ;
  void *tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  int tmp___10 ;
  int tmp___11 ;
  int tmp___12 ;
  timelib_sll tmp___13 ;
  timelib_sll tmp___14 ;
  timelib_sll tmp___15 ;
  int tmp___16 ;
  int tmp___17 ;
  unsigned int tmp___18 ;
  int32_t tmp___19 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1747] == 0) {
    {
    fprintf(_coverage_fout, "1747\n");
    fflush(_coverage_fout);
    ___coverage_array[1747] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = -1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1748] == 0) {
    {
    fprintf(_coverage_fout, "1748\n");
    fflush(_coverage_fout);
    ___coverage_array[1748] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  offset = (timelib_time_offset *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1749] == 0) {
    {
    fprintf(_coverage_fout, "1749\n");
    fflush(_coverage_fout);
    ___coverage_array[1749] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1750] == 0) {
    {
    fprintf(_coverage_fout, "1750\n");
    fflush(_coverage_fout);
    ___coverage_array[1750] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1666] == 0) {
      {
      fprintf(_coverage_fout, "1666\n");
      fflush(_coverage_fout);
      ___coverage_array[1666] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = get_timezone_info();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1667] == 0) {
      {
      fprintf(_coverage_fout, "1667\n");
      fflush(_coverage_fout);
      ___coverage_array[1667] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1668] == 0) {
      {
      fprintf(_coverage_fout, "1668\n");
      fflush(_coverage_fout);
      ___coverage_array[1668] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    t->tz_info = tzi;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1669] == 0) {
      {
      fprintf(_coverage_fout, "1669\n");
      fflush(_coverage_fout);
      ___coverage_array[1669] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    t->zone_type = 3U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1670] == 0) {
      {
      fprintf(_coverage_fout, "1670\n");
      fflush(_coverage_fout);
      ___coverage_array[1670] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2local(t, (long long )ts);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1671] == 0) {
      {
      fprintf(_coverage_fout, "1671\n");
      fflush(_coverage_fout);
      ___coverage_array[1671] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)((void *)0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1672] == 0) {
      {
      fprintf(_coverage_fout, "1672\n");
      fflush(_coverage_fout);
      ___coverage_array[1672] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2gmt(t, (long long )ts);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1751] == 0) {
    {
    fprintf(_coverage_fout, "1751\n");
    fflush(_coverage_fout);
    ___coverage_array[1751] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1702] == 0) {
      {
      fprintf(_coverage_fout, "1702\n");
      fflush(_coverage_fout);
      ___coverage_array[1702] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (t->zone_type == 2U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1673] == 0) {
        {
        fprintf(_coverage_fout, "1673\n");
        fflush(_coverage_fout);
        ___coverage_array[1673] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset = timelib_time_offset_ctor();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1674] == 0) {
        {
        fprintf(_coverage_fout, "1674\n");
        fflush(_coverage_fout);
        ___coverage_array[1674] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->offset = (t->z - t->dst * 60) * -60;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1675] == 0) {
        {
        fprintf(_coverage_fout, "1675\n");
        fflush(_coverage_fout);
        ___coverage_array[1675] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->leap_secs = 0U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1676] == 0) {
        {
        fprintf(_coverage_fout, "1676\n");
        fflush(_coverage_fout);
        ___coverage_array[1676] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->is_dst = (unsigned int )t->dst;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1677] == 0) {
        {
        fprintf(_coverage_fout, "1677\n");
        fflush(_coverage_fout);
        ___coverage_array[1677] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = __strdup((char const   *)t->tz_abbr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1678] == 0) {
        {
        fprintf(_coverage_fout, "1678\n");
        fflush(_coverage_fout);
        ___coverage_array[1678] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      offset->abbr = tmp___5;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1701] == 0) {
        {
        fprintf(_coverage_fout, "1701\n");
        fflush(_coverage_fout);
        ___coverage_array[1701] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (t->zone_type == 1U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1690] == 0) {
          {
          fprintf(_coverage_fout, "1690\n");
          fflush(_coverage_fout);
          ___coverage_array[1690] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = timelib_time_offset_ctor();
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1691] == 0) {
          {
          fprintf(_coverage_fout, "1691\n");
          fflush(_coverage_fout);
          ___coverage_array[1691] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->offset = (t->z - t->dst * 60) * -60;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1692] == 0) {
          {
          fprintf(_coverage_fout, "1692\n");
          fflush(_coverage_fout);
          ___coverage_array[1692] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->leap_secs = 0U;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1693] == 0) {
          {
          fprintf(_coverage_fout, "1693\n");
          fflush(_coverage_fout);
          ___coverage_array[1693] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->is_dst = (unsigned int )t->dst;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1694] == 0) {
          {
          fprintf(_coverage_fout, "1694\n");
          fflush(_coverage_fout);
          ___coverage_array[1694] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___6 = malloc(9U);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1695] == 0) {
          {
          fprintf(_coverage_fout, "1695\n");
          fflush(_coverage_fout);
          ___coverage_array[1695] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset->abbr = (char *)tmp___6;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1696] == 0) {
          {
          fprintf(_coverage_fout, "1696\n");
          fflush(_coverage_fout);
          ___coverage_array[1696] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! localtime___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1679] == 0) {
            {
            fprintf(_coverage_fout, "1679\n");
            fflush(_coverage_fout);
            ___coverage_array[1679] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___7 = abs((offset->offset % 3600) / 60);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1680] == 0) {
            {
            fprintf(_coverage_fout, "1680\n");
            fflush(_coverage_fout);
            ___coverage_array[1680] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = tmp___7;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1681] == 0) {
            {
            fprintf(_coverage_fout, "1681\n");
            fflush(_coverage_fout);
            ___coverage_array[1681] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___8 = 0;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1697] == 0) {
          {
          fprintf(_coverage_fout, "1697\n");
          fflush(_coverage_fout);
          ___coverage_array[1697] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! localtime___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1682] == 0) {
            {
            fprintf(_coverage_fout, "1682\n");
            fflush(_coverage_fout);
            ___coverage_array[1682] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___9 = abs(offset->offset / 3600);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1683] == 0) {
            {
            fprintf(_coverage_fout, "1683\n");
            fflush(_coverage_fout);
            ___coverage_array[1683] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = tmp___9;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1684] == 0) {
            {
            fprintf(_coverage_fout, "1684\n");
            fflush(_coverage_fout);
            ___coverage_array[1684] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___10 = 0;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1698] == 0) {
          {
          fprintf(_coverage_fout, "1698\n");
          fflush(_coverage_fout);
          ___coverage_array[1698] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (! localtime___0) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1687] == 0) {
            {
            fprintf(_coverage_fout, "1687\n");
            fflush(_coverage_fout);
            ___coverage_array[1687] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (offset->offset < 0) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1685] == 0) {
              {
              fprintf(_coverage_fout, "1685\n");
              fflush(_coverage_fout);
              ___coverage_array[1685] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___11 = '-';
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[1686] == 0) {
              {
              fprintf(_coverage_fout, "1686\n");
              fflush(_coverage_fout);
              ___coverage_array[1686] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___11 = '+';
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1688] == 0) {
            {
            fprintf(_coverage_fout, "1688\n");
            fflush(_coverage_fout);
            ___coverage_array[1688] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___12 = tmp___11;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1689] == 0) {
            {
            fprintf(_coverage_fout, "1689\n");
            fflush(_coverage_fout);
            ___coverage_array[1689] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___12 = '+';
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1699] == 0) {
          {
          fprintf(_coverage_fout, "1699\n");
          fflush(_coverage_fout);
          ___coverage_array[1699] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ap_php_snprintf(offset->abbr, 9U, "GMT%c%02d%02d", tmp___12, tmp___10,
                        tmp___8);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1700] == 0) {
          {
          fprintf(_coverage_fout, "1700\n");
          fflush(_coverage_fout);
          ___coverage_array[1700] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        offset = timelib_get_time_zone_info(t->sse, t->tz_info);
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1703] == 0) {
      {
      fprintf(_coverage_fout, "1703\n");
      fflush(_coverage_fout);
      ___coverage_array[1703] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1752] == 0) {
    {
    fprintf(_coverage_fout, "1752\n");
    fflush(_coverage_fout);
    ___coverage_array[1752] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_isoweek_from_date(t->y, t->m, t->d, & isoweek, & isoyear);
  switch ((int )format) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1719] == 0) {
    {
    fprintf(_coverage_fout, "1719\n");
    fflush(_coverage_fout);
    ___coverage_array[1719] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 100: 
  case 106: 
  retval = (int )t->d;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1720] == 0) {
    {
    fprintf(_coverage_fout, "1720\n");
    fflush(_coverage_fout);
    ___coverage_array[1720] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 119: 
  tmp___13 = timelib_day_of_week(t->y, t->m, t->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1721] == 0) {
    {
    fprintf(_coverage_fout, "1721\n");
    fflush(_coverage_fout);
    ___coverage_array[1721] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (int )tmp___13;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1722] == 0) {
    {
    fprintf(_coverage_fout, "1722\n");
    fflush(_coverage_fout);
    ___coverage_array[1722] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 122: 
  tmp___14 = timelib_day_of_year(t->y, t->m, t->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1723] == 0) {
    {
    fprintf(_coverage_fout, "1723\n");
    fflush(_coverage_fout);
    ___coverage_array[1723] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (int )tmp___14;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1724] == 0) {
    {
    fprintf(_coverage_fout, "1724\n");
    fflush(_coverage_fout);
    ___coverage_array[1724] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 87: 
  retval = (int )isoweek;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1725] == 0) {
    {
    fprintf(_coverage_fout, "1725\n");
    fflush(_coverage_fout);
    ___coverage_array[1725] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 109: 
  case 110: 
  retval = (int )t->m;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1726] == 0) {
    {
    fprintf(_coverage_fout, "1726\n");
    fflush(_coverage_fout);
    ___coverage_array[1726] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 116: 
  tmp___15 = timelib_days_in_month(t->y, t->m);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1727] == 0) {
    {
    fprintf(_coverage_fout, "1727\n");
    fflush(_coverage_fout);
    ___coverage_array[1727] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (int )tmp___15;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1728] == 0) {
    {
    fprintf(_coverage_fout, "1728\n");
    fflush(_coverage_fout);
    ___coverage_array[1728] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 76: 
  if ((int )t->y % 4 == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1708] == 0) {
      {
      fprintf(_coverage_fout, "1708\n");
      fflush(_coverage_fout);
      ___coverage_array[1708] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )t->y % 100 != 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1704] == 0) {
        {
        fprintf(_coverage_fout, "1704\n");
        fflush(_coverage_fout);
        ___coverage_array[1704] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___16 = 1;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1707] == 0) {
        {
        fprintf(_coverage_fout, "1707\n");
        fflush(_coverage_fout);
        ___coverage_array[1707] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )t->y % 400 == 0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1705] == 0) {
          {
          fprintf(_coverage_fout, "1705\n");
          fflush(_coverage_fout);
          ___coverage_array[1705] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___16 = 1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1706] == 0) {
          {
          fprintf(_coverage_fout, "1706\n");
          fflush(_coverage_fout);
          ___coverage_array[1706] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___16 = 0;
      }
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1709] == 0) {
      {
      fprintf(_coverage_fout, "1709\n");
      fflush(_coverage_fout);
      ___coverage_array[1709] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___16 = 0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1729] == 0) {
    {
    fprintf(_coverage_fout, "1729\n");
    fflush(_coverage_fout);
    ___coverage_array[1729] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = tmp___16;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1730] == 0) {
    {
    fprintf(_coverage_fout, "1730\n");
    fflush(_coverage_fout);
    ___coverage_array[1730] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 121: 
  retval = (int )(t->y % 100LL);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1731] == 0) {
    {
    fprintf(_coverage_fout, "1731\n");
    fflush(_coverage_fout);
    ___coverage_array[1731] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 89: 
  retval = (int )t->y;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1732] == 0) {
    {
    fprintf(_coverage_fout, "1732\n");
    fflush(_coverage_fout);
    ___coverage_array[1732] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 66: 
  retval = (int )((((long )t->sse - ((long )t->sse - ((long )t->sse % 86400L + 3600L))) * 10L) / 864L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1733] == 0) {
    {
    fprintf(_coverage_fout, "1733\n");
    fflush(_coverage_fout);
    ___coverage_array[1733] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1711] == 0) {
      {
      fprintf(_coverage_fout, "1711\n");
      fflush(_coverage_fout);
      ___coverage_array[1711] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (retval < 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1710] == 0) {
        {
        fprintf(_coverage_fout, "1710\n");
        fflush(_coverage_fout);
        ___coverage_array[1710] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1712] == 0) {
      {
      fprintf(_coverage_fout, "1712\n");
      fflush(_coverage_fout);
      ___coverage_array[1712] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval += 1000;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1734] == 0) {
    {
    fprintf(_coverage_fout, "1734\n");
    fflush(_coverage_fout);
    ___coverage_array[1734] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval %= 1000;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1735] == 0) {
    {
    fprintf(_coverage_fout, "1735\n");
    fflush(_coverage_fout);
    ___coverage_array[1735] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 103: 
  case 104: 
  if (t->h % 12LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1713] == 0) {
      {
      fprintf(_coverage_fout, "1713\n");
      fflush(_coverage_fout);
      ___coverage_array[1713] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___17 = (int )t->h % 12;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1714] == 0) {
      {
      fprintf(_coverage_fout, "1714\n");
      fflush(_coverage_fout);
      ___coverage_array[1714] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___17 = 12;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1736] == 0) {
    {
    fprintf(_coverage_fout, "1736\n");
    fflush(_coverage_fout);
    ___coverage_array[1736] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = tmp___17;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1737] == 0) {
    {
    fprintf(_coverage_fout, "1737\n");
    fflush(_coverage_fout);
    ___coverage_array[1737] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 72: 
  case 71: 
  retval = (int )t->h;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1738] == 0) {
    {
    fprintf(_coverage_fout, "1738\n");
    fflush(_coverage_fout);
    ___coverage_array[1738] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 105: 
  retval = (int )t->i;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1739] == 0) {
    {
    fprintf(_coverage_fout, "1739\n");
    fflush(_coverage_fout);
    ___coverage_array[1739] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 115: 
  retval = (int )t->s;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1740] == 0) {
    {
    fprintf(_coverage_fout, "1740\n");
    fflush(_coverage_fout);
    ___coverage_array[1740] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 73: 
  if (! localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1715] == 0) {
      {
      fprintf(_coverage_fout, "1715\n");
      fflush(_coverage_fout);
      ___coverage_array[1715] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___18 = offset->is_dst;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1716] == 0) {
      {
      fprintf(_coverage_fout, "1716\n");
      fflush(_coverage_fout);
      ___coverage_array[1716] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___18 = 0U;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1741] == 0) {
    {
    fprintf(_coverage_fout, "1741\n");
    fflush(_coverage_fout);
    ___coverage_array[1741] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = (int )tmp___18;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1742] == 0) {
    {
    fprintf(_coverage_fout, "1742\n");
    fflush(_coverage_fout);
    ___coverage_array[1742] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 90: 
  if (! localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1717] == 0) {
      {
      fprintf(_coverage_fout, "1717\n");
      fflush(_coverage_fout);
      ___coverage_array[1717] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___19 = offset->offset;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1718] == 0) {
      {
      fprintf(_coverage_fout, "1718\n");
      fflush(_coverage_fout);
      ___coverage_array[1718] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___19 = 0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1743] == 0) {
    {
    fprintf(_coverage_fout, "1743\n");
    fflush(_coverage_fout);
    ___coverage_array[1743] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = tmp___19;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1744] == 0) {
    {
    fprintf(_coverage_fout, "1744\n");
    fflush(_coverage_fout);
    ___coverage_array[1744] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 85: 
  retval = (int )t->sse;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1753] == 0) {
    {
    fprintf(_coverage_fout, "1753\n");
    fflush(_coverage_fout);
    ___coverage_array[1753] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! localtime___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1745] == 0) {
      {
      fprintf(_coverage_fout, "1745\n");
      fflush(_coverage_fout);
      ___coverage_array[1745] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_offset_dtor(offset);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1746] == 0) {
      {
      fprintf(_coverage_fout, "1746\n");
      fflush(_coverage_fout);
      ___coverage_array[1746] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1754] == 0) {
    {
    fprintf(_coverage_fout, "1754\n");
    fflush(_coverage_fout);
    ___coverage_array[1754] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(t);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1755] == 0) {
    {
    fprintf(_coverage_fout, "1755\n");
    fflush(_coverage_fout);
    ___coverage_array[1755] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )retval);
}
}
void zif_date(int ht , zval *return_value , zval **return_value_ptr ,
              zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1756] == 0) {
    {
    fprintf(_coverage_fout, "1756\n");
    fflush(_coverage_fout);
    ___coverage_array[1756] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date(ht, return_value, return_value_ptr, this_ptr, return_value_used, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1757] == 0) {
    {
    fprintf(_coverage_fout, "1757\n");
    fflush(_coverage_fout);
    ___coverage_array[1757] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_gmdate(int ht , zval *return_value , zval **return_value_ptr ,
                zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1758] == 0) {
    {
    fprintf(_coverage_fout, "1758\n");
    fflush(_coverage_fout);
    ___coverage_array[1758] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date(ht, return_value, return_value_ptr, this_ptr, return_value_used, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1759] == 0) {
    {
    fprintf(_coverage_fout, "1759\n");
    fflush(_coverage_fout);
    ___coverage_array[1759] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_idate(int ht , zval *return_value , zval **return_value_ptr ,
               zval *this_ptr , int return_value_used ) 
{ char *format ;
  int format_len ;
  long ts ;
  int ret ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval *__z___1 ;
  zval *__z___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1782] == 0) {
    {
    fprintf(_coverage_fout, "1782\n");
    fflush(_coverage_fout);
    ___coverage_array[1782] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1783] == 0) {
    {
    fprintf(_coverage_fout, "1783\n");
    fflush(_coverage_fout);
    ___coverage_array[1783] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s|l", & format, & format_len, & ts);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1784] == 0) {
    {
    fprintf(_coverage_fout, "1784\n");
    fflush(_coverage_fout);
    ___coverage_array[1784] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1763] == 0) {
      {
      fprintf(_coverage_fout, "1763\n");
      fflush(_coverage_fout);
      ___coverage_array[1763] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1760] == 0) {
        {
        fprintf(_coverage_fout, "1760\n");
        fflush(_coverage_fout);
        ___coverage_array[1760] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1761] == 0) {
        {
        fprintf(_coverage_fout, "1761\n");
        fflush(_coverage_fout);
        ___coverage_array[1761] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1762] == 0) {
        {
        fprintf(_coverage_fout, "1762\n");
        fflush(_coverage_fout);
        ___coverage_array[1762] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1764] == 0) {
      {
      fprintf(_coverage_fout, "1764\n");
      fflush(_coverage_fout);
      ___coverage_array[1764] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1765] == 0) {
      {
      fprintf(_coverage_fout, "1765\n");
      fflush(_coverage_fout);
      ___coverage_array[1765] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1785] == 0) {
    {
    fprintf(_coverage_fout, "1785\n");
    fflush(_coverage_fout);
    ___coverage_array[1785] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (format_len != 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1769] == 0) {
      {
      fprintf(_coverage_fout, "1769\n");
      fflush(_coverage_fout);
      ___coverage_array[1769] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "idate format is one char");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1770] == 0) {
      {
      fprintf(_coverage_fout, "1770\n");
      fflush(_coverage_fout);
      ___coverage_array[1770] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1766] == 0) {
        {
        fprintf(_coverage_fout, "1766\n");
        fflush(_coverage_fout);
        ___coverage_array[1766] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1767] == 0) {
        {
        fprintf(_coverage_fout, "1767\n");
        fflush(_coverage_fout);
        ___coverage_array[1767] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1768] == 0) {
        {
        fprintf(_coverage_fout, "1768\n");
        fflush(_coverage_fout);
        ___coverage_array[1768] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1771] == 0) {
      {
      fprintf(_coverage_fout, "1771\n");
      fflush(_coverage_fout);
      ___coverage_array[1771] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1772] == 0) {
      {
      fprintf(_coverage_fout, "1772\n");
      fflush(_coverage_fout);
      ___coverage_array[1772] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1786] == 0) {
    {
    fprintf(_coverage_fout, "1786\n");
    fflush(_coverage_fout);
    ___coverage_array[1786] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ht == 1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1773] == 0) {
      {
      fprintf(_coverage_fout, "1773\n");
      fflush(_coverage_fout);
      ___coverage_array[1773] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ts = time((time_t *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1774] == 0) {
      {
      fprintf(_coverage_fout, "1774\n");
      fflush(_coverage_fout);
      ___coverage_array[1774] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1787] == 0) {
    {
    fprintf(_coverage_fout, "1787\n");
    fflush(_coverage_fout);
    ___coverage_array[1787] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = php_idate(*(format + 0), ts, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1788] == 0) {
    {
    fprintf(_coverage_fout, "1788\n");
    fflush(_coverage_fout);
    ___coverage_array[1788] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ret = (int )tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1789] == 0) {
    {
    fprintf(_coverage_fout, "1789\n");
    fflush(_coverage_fout);
    ___coverage_array[1789] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ret == -1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1778] == 0) {
      {
      fprintf(_coverage_fout, "1778\n");
      fflush(_coverage_fout);
      ___coverage_array[1778] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Unrecognized date format token.");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1779] == 0) {
      {
      fprintf(_coverage_fout, "1779\n");
      fflush(_coverage_fout);
      ___coverage_array[1779] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1775] == 0) {
        {
        fprintf(_coverage_fout, "1775\n");
        fflush(_coverage_fout);
        ___coverage_array[1775] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1776] == 0) {
        {
        fprintf(_coverage_fout, "1776\n");
        fflush(_coverage_fout);
        ___coverage_array[1776] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1777] == 0) {
        {
        fprintf(_coverage_fout, "1777\n");
        fflush(_coverage_fout);
        ___coverage_array[1777] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1780] == 0) {
      {
      fprintf(_coverage_fout, "1780\n");
      fflush(_coverage_fout);
      ___coverage_array[1780] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1781] == 0) {
      {
      fprintf(_coverage_fout, "1781\n");
      fflush(_coverage_fout);
      ___coverage_array[1781] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1790] == 0) {
    {
    fprintf(_coverage_fout, "1790\n");
    fflush(_coverage_fout);
    ___coverage_array[1790] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2 = return_value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1791] == 0) {
    {
    fprintf(_coverage_fout, "1791\n");
    fflush(_coverage_fout);
    ___coverage_array[1791] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->value.lval = (long )ret;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1792] == 0) {
    {
    fprintf(_coverage_fout, "1792\n");
    fflush(_coverage_fout);
    ___coverage_array[1792] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1793] == 0) {
    {
    fprintf(_coverage_fout, "1793\n");
    fflush(_coverage_fout);
    ___coverage_array[1793] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void __attribute__((__visibility__("default")))  php_date_set_tzdb(timelib_tzdb *tzdb ) 
{ timelib_tzdb const   *builtin ;
  timelib_tzdb const   *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1797] == 0) {
    {
    fprintf(_coverage_fout, "1797\n");
    fflush(_coverage_fout);
    ___coverage_array[1797] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = timelib_builtin_db();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1798] == 0) {
    {
    fprintf(_coverage_fout, "1798\n");
    fflush(_coverage_fout);
    ___coverage_array[1798] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  builtin = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1799] == 0) {
    {
    fprintf(_coverage_fout, "1799\n");
    fflush(_coverage_fout);
    ___coverage_array[1799] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = php_version_compare((char const   *)tzdb->version,
                                (char const   *)builtin->version);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1800] == 0) {
    {
    fprintf(_coverage_fout, "1800\n");
    fflush(_coverage_fout);
    ___coverage_array[1800] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0 > (int __attribute__((__visibility__("default")))  )0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1794] == 0) {
      {
      fprintf(_coverage_fout, "1794\n");
      fflush(_coverage_fout);
      ___coverage_array[1794] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_date_global_timezone_db = tzdb;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1795] == 0) {
      {
      fprintf(_coverage_fout, "1795\n");
      fflush(_coverage_fout);
      ___coverage_array[1795] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_date_global_timezone_db_enabled = 1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1796] == 0) {
      {
      fprintf(_coverage_fout, "1796\n");
      fflush(_coverage_fout);
      ___coverage_array[1796] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1801] == 0) {
    {
    fprintf(_coverage_fout, "1801\n");
    fflush(_coverage_fout);
    ___coverage_array[1801] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
long __attribute__((__visibility__("default")))  php_parse_date(char *string ,
                                                                long *now ) 
{ timelib_time *parsed_time ;
  timelib_error_container *error ;
  int error2 ;
  long retval ;
  timelib_tzdb const   *tmp ;
  timelib_tzdb const   *tmp___0 ;
  size_t tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1810] == 0) {
    {
    fprintf(_coverage_fout, "1810\n");
    fflush(_coverage_fout);
    ___coverage_array[1810] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  error = (timelib_error_container *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1811] == 0) {
    {
    fprintf(_coverage_fout, "1811\n");
    fflush(_coverage_fout);
    ___coverage_array[1811] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1802] == 0) {
      {
      fprintf(_coverage_fout, "1802\n");
      fflush(_coverage_fout);
      ___coverage_array[1802] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1803] == 0) {
      {
      fprintf(_coverage_fout, "1803\n");
      fflush(_coverage_fout);
      ___coverage_array[1803] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1804] == 0) {
      {
      fprintf(_coverage_fout, "1804\n");
      fflush(_coverage_fout);
      ___coverage_array[1804] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1812] == 0) {
    {
    fprintf(_coverage_fout, "1812\n");
    fflush(_coverage_fout);
    ___coverage_array[1812] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = strlen((char const   *)string);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1813] == 0) {
    {
    fprintf(_coverage_fout, "1813\n");
    fflush(_coverage_fout);
    ___coverage_array[1813] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  parsed_time = timelib_strtotime(string, (int )tmp___1, & error, tmp___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1814] == 0) {
    {
    fprintf(_coverage_fout, "1814\n");
    fflush(_coverage_fout);
    ___coverage_array[1814] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (error->error_count) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1805] == 0) {
      {
      fprintf(_coverage_fout, "1805\n");
      fflush(_coverage_fout);
      ___coverage_array[1805] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_error_container_dtor(error);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1806] == 0) {
      {
      fprintf(_coverage_fout, "1806\n");
      fflush(_coverage_fout);
      ___coverage_array[1806] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((long __attribute__((__visibility__("default")))  )-1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1807] == 0) {
      {
      fprintf(_coverage_fout, "1807\n");
      fflush(_coverage_fout);
      ___coverage_array[1807] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1815] == 0) {
    {
    fprintf(_coverage_fout, "1815\n");
    fflush(_coverage_fout);
    ___coverage_array[1815] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_error_container_dtor(error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1816] == 0) {
    {
    fprintf(_coverage_fout, "1816\n");
    fflush(_coverage_fout);
    ___coverage_array[1816] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(parsed_time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1817] == 0) {
    {
    fprintf(_coverage_fout, "1817\n");
    fflush(_coverage_fout);
    ___coverage_array[1817] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = timelib_date_to_int(parsed_time, & error2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1818] == 0) {
    {
    fprintf(_coverage_fout, "1818\n");
    fflush(_coverage_fout);
    ___coverage_array[1818] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(parsed_time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1819] == 0) {
    {
    fprintf(_coverage_fout, "1819\n");
    fflush(_coverage_fout);
    ___coverage_array[1819] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (error2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1808] == 0) {
      {
      fprintf(_coverage_fout, "1808\n");
      fflush(_coverage_fout);
      ___coverage_array[1808] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((long __attribute__((__visibility__("default")))  )-1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1809] == 0) {
      {
      fprintf(_coverage_fout, "1809\n");
      fflush(_coverage_fout);
      ___coverage_array[1809] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1820] == 0) {
    {
    fprintf(_coverage_fout, "1820\n");
    fflush(_coverage_fout);
    ___coverage_array[1820] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((long __attribute__((__visibility__("default")))  )retval);
}
}
void zif_strtotime(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) 
{ char *times ;
  char *initial_ts ;
  int time_len ;
  int error1 ;
  int error2 ;
  struct timelib_error_container *error ;
  long preset_ts ;
  long ts ;
  timelib_time *t ;
  timelib_time *now ;
  timelib_tzinfo *tzi ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;
  timelib_tzdb const   *tmp___2 ;
  size_t tmp___3 ;
  time_t tmp___4 ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;
  zval *__z___0 ;
  timelib_tzdb const   *tmp___7 ;
  timelib_tzdb const   *tmp___8 ;
  zval *__z___1 ;
  zval *__z___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1869] == 0) {
    {
    fprintf(_coverage_fout, "1869\n");
    fflush(_coverage_fout);
    ___coverage_array[1869] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  preset_ts = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1870] == 0) {
    {
    fprintf(_coverage_fout, "1870\n");
    fflush(_coverage_fout);
    ___coverage_array[1870] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = get_timezone_info();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1871] == 0) {
    {
    fprintf(_coverage_fout, "1871\n");
    fflush(_coverage_fout);
    ___coverage_array[1871] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1872] == 0) {
    {
    fprintf(_coverage_fout, "1872\n");
    fflush(_coverage_fout);
    ___coverage_array[1872] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___6 = zend_parse_parameters_ex(1 << 1, ht, "sl", & times, & time_len,
                                     & preset_ts);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1873] == 0) {
    {
    fprintf(_coverage_fout, "1873\n");
    fflush(_coverage_fout);
    ___coverage_array[1873] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___6 != (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1824] == 0) {
      {
      fprintf(_coverage_fout, "1824\n");
      fflush(_coverage_fout);
      ___coverage_array[1824] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    now = timelib_time_ctor();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1825] == 0) {
      {
      fprintf(_coverage_fout, "1825\n");
      fflush(_coverage_fout);
      ___coverage_array[1825] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = _emalloc(25U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1826] == 0) {
      {
      fprintf(_coverage_fout, "1826\n");
      fflush(_coverage_fout);
      ___coverage_array[1826] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    initial_ts = (char *)tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1827] == 0) {
      {
      fprintf(_coverage_fout, "1827\n");
      fflush(_coverage_fout);
      ___coverage_array[1827] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ap_php_snprintf(initial_ts, 24U, "@%ld UTC", preset_ts);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1828] == 0) {
      {
      fprintf(_coverage_fout, "1828\n");
      fflush(_coverage_fout);
      ___coverage_array[1828] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (php_date_global_timezone_db) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1821] == 0) {
        {
        fprintf(_coverage_fout, "1821\n");
        fflush(_coverage_fout);
        ___coverage_array[1821] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = (timelib_tzdb const   *)php_date_global_timezone_db;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1822] == 0) {
        {
        fprintf(_coverage_fout, "1822\n");
        fflush(_coverage_fout);
        ___coverage_array[1822] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = timelib_builtin_db();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1823] == 0) {
        {
        fprintf(_coverage_fout, "1823\n");
        fflush(_coverage_fout);
        ___coverage_array[1823] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = tmp___1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1829] == 0) {
      {
      fprintf(_coverage_fout, "1829\n");
      fflush(_coverage_fout);
      ___coverage_array[1829] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = strlen((char const   *)initial_ts);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1830] == 0) {
      {
      fprintf(_coverage_fout, "1830\n");
      fflush(_coverage_fout);
      ___coverage_array[1830] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    t = timelib_strtotime(initial_ts, (int )tmp___3,
                          (timelib_error_container **)((void *)0), tmp___2);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1831] == 0) {
      {
      fprintf(_coverage_fout, "1831\n");
      fflush(_coverage_fout);
      ___coverage_array[1831] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_update_ts(t, tzi);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1832] == 0) {
      {
      fprintf(_coverage_fout, "1832\n");
      fflush(_coverage_fout);
      ___coverage_array[1832] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    now->tz_info = tzi;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1833] == 0) {
      {
      fprintf(_coverage_fout, "1833\n");
      fflush(_coverage_fout);
      ___coverage_array[1833] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    now->zone_type = 3U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1834] == 0) {
      {
      fprintf(_coverage_fout, "1834\n");
      fflush(_coverage_fout);
      ___coverage_array[1834] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2local(now, t->sse);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1835] == 0) {
      {
      fprintf(_coverage_fout, "1835\n");
      fflush(_coverage_fout);
      ___coverage_array[1835] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(t);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1836] == 0) {
      {
      fprintf(_coverage_fout, "1836\n");
      fflush(_coverage_fout);
      ___coverage_array[1836] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)initial_ts);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1847] == 0) {
      {
      fprintf(_coverage_fout, "1847\n");
      fflush(_coverage_fout);
      ___coverage_array[1847] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = zend_parse_parameters(ht, "s|l", & times, & time_len, & preset_ts);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1848] == 0) {
      {
      fprintf(_coverage_fout, "1848\n");
      fflush(_coverage_fout);
      ___coverage_array[1848] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___5 != (int __attribute__((__visibility__("default")))  )-1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1837] == 0) {
        {
        fprintf(_coverage_fout, "1837\n");
        fflush(_coverage_fout);
        ___coverage_array[1837] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      now = timelib_time_ctor();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1838] == 0) {
        {
        fprintf(_coverage_fout, "1838\n");
        fflush(_coverage_fout);
        ___coverage_array[1838] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      now->tz_info = tzi;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1839] == 0) {
        {
        fprintf(_coverage_fout, "1839\n");
        fflush(_coverage_fout);
        ___coverage_array[1839] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      now->zone_type = 3U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1840] == 0) {
        {
        fprintf(_coverage_fout, "1840\n");
        fflush(_coverage_fout);
        ___coverage_array[1840] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = time((time_t *)((void *)0));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1841] == 0) {
        {
        fprintf(_coverage_fout, "1841\n");
        fflush(_coverage_fout);
        ___coverage_array[1841] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_unixtime2local(now, (long long )tmp___4);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1845] == 0) {
        {
        fprintf(_coverage_fout, "1845\n");
        fflush(_coverage_fout);
        ___coverage_array[1845] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1842] == 0) {
          {
          fprintf(_coverage_fout, "1842\n");
          fflush(_coverage_fout);
          ___coverage_array[1842] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z = return_value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1843] == 0) {
          {
          fprintf(_coverage_fout, "1843\n");
          fflush(_coverage_fout);
          ___coverage_array[1843] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z->value.lval = 0L;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1844] == 0) {
          {
          fprintf(_coverage_fout, "1844\n");
          fflush(_coverage_fout);
          ___coverage_array[1844] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z->type = (unsigned char)3;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1846] == 0) {
        {
        fprintf(_coverage_fout, "1846\n");
        fflush(_coverage_fout);
        ___coverage_array[1846] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1874] == 0) {
    {
    fprintf(_coverage_fout, "1874\n");
    fflush(_coverage_fout);
    ___coverage_array[1874] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! time_len) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1852] == 0) {
      {
      fprintf(_coverage_fout, "1852\n");
      fflush(_coverage_fout);
      ___coverage_array[1852] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(now);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1853] == 0) {
      {
      fprintf(_coverage_fout, "1853\n");
      fflush(_coverage_fout);
      ___coverage_array[1853] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1849] == 0) {
        {
        fprintf(_coverage_fout, "1849\n");
        fflush(_coverage_fout);
        ___coverage_array[1849] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1850] == 0) {
        {
        fprintf(_coverage_fout, "1850\n");
        fflush(_coverage_fout);
        ___coverage_array[1850] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1851] == 0) {
        {
        fprintf(_coverage_fout, "1851\n");
        fflush(_coverage_fout);
        ___coverage_array[1851] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1854] == 0) {
      {
      fprintf(_coverage_fout, "1854\n");
      fflush(_coverage_fout);
      ___coverage_array[1854] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1855] == 0) {
      {
      fprintf(_coverage_fout, "1855\n");
      fflush(_coverage_fout);
      ___coverage_array[1855] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1875] == 0) {
    {
    fprintf(_coverage_fout, "1875\n");
    fflush(_coverage_fout);
    ___coverage_array[1875] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1856] == 0) {
      {
      fprintf(_coverage_fout, "1856\n");
      fflush(_coverage_fout);
      ___coverage_array[1856] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___8 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1857] == 0) {
      {
      fprintf(_coverage_fout, "1857\n");
      fflush(_coverage_fout);
      ___coverage_array[1857] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1858] == 0) {
      {
      fprintf(_coverage_fout, "1858\n");
      fflush(_coverage_fout);
      ___coverage_array[1858] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___8 = tmp___7;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1876] == 0) {
    {
    fprintf(_coverage_fout, "1876\n");
    fflush(_coverage_fout);
    ___coverage_array[1876] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t = timelib_strtotime(times, time_len, & error, tmp___8);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1877] == 0) {
    {
    fprintf(_coverage_fout, "1877\n");
    fflush(_coverage_fout);
    ___coverage_array[1877] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  error1 = error->error_count;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1878] == 0) {
    {
    fprintf(_coverage_fout, "1878\n");
    fflush(_coverage_fout);
    ___coverage_array[1878] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_error_container_dtor(error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1879] == 0) {
    {
    fprintf(_coverage_fout, "1879\n");
    fflush(_coverage_fout);
    ___coverage_array[1879] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_fill_holes(t, now, 0x02);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1880] == 0) {
    {
    fprintf(_coverage_fout, "1880\n");
    fflush(_coverage_fout);
    ___coverage_array[1880] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(t, tzi);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1881] == 0) {
    {
    fprintf(_coverage_fout, "1881\n");
    fflush(_coverage_fout);
    ___coverage_array[1881] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts = timelib_date_to_int(t, & error2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1882] == 0) {
    {
    fprintf(_coverage_fout, "1882\n");
    fflush(_coverage_fout);
    ___coverage_array[1882] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(now);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1883] == 0) {
    {
    fprintf(_coverage_fout, "1883\n");
    fflush(_coverage_fout);
    ___coverage_array[1883] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(t);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1884] == 0) {
    {
    fprintf(_coverage_fout, "1884\n");
    fflush(_coverage_fout);
    ___coverage_array[1884] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (error1) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1868] == 0) {
      {
      fprintf(_coverage_fout, "1868\n");
      fflush(_coverage_fout);
      ___coverage_array[1868] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (error2) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1862] == 0) {
        {
        fprintf(_coverage_fout, "1862\n");
        fflush(_coverage_fout);
        ___coverage_array[1862] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _L: /* CIL Label */ 
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1859] == 0) {
          {
          fprintf(_coverage_fout, "1859\n");
          fflush(_coverage_fout);
          ___coverage_array[1859] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1 = return_value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1860] == 0) {
          {
          fprintf(_coverage_fout, "1860\n");
          fflush(_coverage_fout);
          ___coverage_array[1860] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->value.lval = 0L;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1861] == 0) {
          {
          fprintf(_coverage_fout, "1861\n");
          fflush(_coverage_fout);
          ___coverage_array[1861] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->type = (unsigned char)3;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1863] == 0) {
        {
        fprintf(_coverage_fout, "1863\n");
        fflush(_coverage_fout);
        ___coverage_array[1863] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1864] == 0) {
        {
        fprintf(_coverage_fout, "1864\n");
        fflush(_coverage_fout);
        ___coverage_array[1864] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1865] == 0) {
        {
        fprintf(_coverage_fout, "1865\n");
        fflush(_coverage_fout);
        ___coverage_array[1865] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->value.lval = ts;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1866] == 0) {
        {
        fprintf(_coverage_fout, "1866\n");
        fflush(_coverage_fout);
        ___coverage_array[1866] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->type = (unsigned char)1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1867] == 0) {
        {
        fprintf(_coverage_fout, "1867\n");
        fflush(_coverage_fout);
        ___coverage_array[1867] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return;
    }
  }
}
}
void __attribute__((__visibility__("default")))  php_mktime(int ht ,
                                                            zval *return_value ,
                                                            zval **return_value_ptr ,
                                                            zval *this_ptr ,
                                                            int return_value_used ,
                                                            int gmt ) 
{ long hou ;
  long min ;
  long sec ;
  long mon ;
  long day ;
  long yea ;
  long dst ;
  timelib_time *now ;
  timelib_tzinfo *tzi ;
  long ts ;
  long adjust_seconds ;
  int error ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  time_t tmp___0 ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___1 ;
  time_t tmp___2 ;
  timelib_time_offset *tmp_offset ;
  zval *__z___0 ;
  zval *__z___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1943] == 0) {
    {
    fprintf(_coverage_fout, "1943\n");
    fflush(_coverage_fout);
    ___coverage_array[1943] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  hou = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1944] == 0) {
    {
    fprintf(_coverage_fout, "1944\n");
    fflush(_coverage_fout);
    ___coverage_array[1944] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  min = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1945] == 0) {
    {
    fprintf(_coverage_fout, "1945\n");
    fflush(_coverage_fout);
    ___coverage_array[1945] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  sec = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1946] == 0) {
    {
    fprintf(_coverage_fout, "1946\n");
    fflush(_coverage_fout);
    ___coverage_array[1946] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  mon = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1947] == 0) {
    {
    fprintf(_coverage_fout, "1947\n");
    fflush(_coverage_fout);
    ___coverage_array[1947] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  day = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1948] == 0) {
    {
    fprintf(_coverage_fout, "1948\n");
    fflush(_coverage_fout);
    ___coverage_array[1948] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  yea = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1949] == 0) {
    {
    fprintf(_coverage_fout, "1949\n");
    fflush(_coverage_fout);
    ___coverage_array[1949] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dst = -1L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1950] == 0) {
    {
    fprintf(_coverage_fout, "1950\n");
    fflush(_coverage_fout);
    ___coverage_array[1950] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1951] == 0) {
    {
    fprintf(_coverage_fout, "1951\n");
    fflush(_coverage_fout);
    ___coverage_array[1951] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  adjust_seconds = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1952] == 0) {
    {
    fprintf(_coverage_fout, "1952\n");
    fflush(_coverage_fout);
    ___coverage_array[1952] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "|lllllll", & hou, & min, & sec, & mon, & day,
                              & yea, & dst);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1953] == 0) {
    {
    fprintf(_coverage_fout, "1953\n");
    fflush(_coverage_fout);
    ___coverage_array[1953] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1888] == 0) {
      {
      fprintf(_coverage_fout, "1888\n");
      fflush(_coverage_fout);
      ___coverage_array[1888] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1885] == 0) {
        {
        fprintf(_coverage_fout, "1885\n");
        fflush(_coverage_fout);
        ___coverage_array[1885] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1886] == 0) {
        {
        fprintf(_coverage_fout, "1886\n");
        fflush(_coverage_fout);
        ___coverage_array[1886] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1887] == 0) {
        {
        fprintf(_coverage_fout, "1887\n");
        fflush(_coverage_fout);
        ___coverage_array[1887] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1889] == 0) {
      {
      fprintf(_coverage_fout, "1889\n");
      fflush(_coverage_fout);
      ___coverage_array[1889] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1890] == 0) {
      {
      fprintf(_coverage_fout, "1890\n");
      fflush(_coverage_fout);
      ___coverage_array[1890] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1954] == 0) {
    {
    fprintf(_coverage_fout, "1954\n");
    fflush(_coverage_fout);
    ___coverage_array[1954] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  now = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1955] == 0) {
    {
    fprintf(_coverage_fout, "1955\n");
    fflush(_coverage_fout);
    ___coverage_array[1955] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (gmt) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1891] == 0) {
      {
      fprintf(_coverage_fout, "1891\n");
      fflush(_coverage_fout);
      ___coverage_array[1891] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = time((time_t *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1892] == 0) {
      {
      fprintf(_coverage_fout, "1892\n");
      fflush(_coverage_fout);
      ___coverage_array[1892] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2gmt(now, (long long )tmp___0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1893] == 0) {
      {
      fprintf(_coverage_fout, "1893\n");
      fflush(_coverage_fout);
      ___coverage_array[1893] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = get_timezone_info();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1894] == 0) {
      {
      fprintf(_coverage_fout, "1894\n");
      fflush(_coverage_fout);
      ___coverage_array[1894] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1895] == 0) {
      {
      fprintf(_coverage_fout, "1895\n");
      fflush(_coverage_fout);
      ___coverage_array[1895] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    now->tz_info = tzi;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1896] == 0) {
      {
      fprintf(_coverage_fout, "1896\n");
      fflush(_coverage_fout);
      ___coverage_array[1896] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    now->zone_type = 3U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1897] == 0) {
      {
      fprintf(_coverage_fout, "1897\n");
      fflush(_coverage_fout);
      ___coverage_array[1897] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = time((time_t *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1898] == 0) {
      {
      fprintf(_coverage_fout, "1898\n");
      fflush(_coverage_fout);
      ___coverage_array[1898] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2local(now, (long long )tmp___2);
  }
  switch (ht) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1906] == 0) {
    {
    fprintf(_coverage_fout, "1906\n");
    fflush(_coverage_fout);
    ___coverage_array[1906] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 7: 
  case 6: 
  if (yea >= 0L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1900] == 0) {
      {
      fprintf(_coverage_fout, "1900\n");
      fflush(_coverage_fout);
      ___coverage_array[1900] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (yea < 70L) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1899] == 0) {
        {
        fprintf(_coverage_fout, "1899\n");
        fflush(_coverage_fout);
        ___coverage_array[1899] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      yea += 2000L;
    } else {
      goto _L;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1905] == 0) {
      {
      fprintf(_coverage_fout, "1905\n");
      fflush(_coverage_fout);
      ___coverage_array[1905] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _L: /* CIL Label */ 
    if (yea >= 70L) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1903] == 0) {
        {
        fprintf(_coverage_fout, "1903\n");
        fflush(_coverage_fout);
        ___coverage_array[1903] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (yea <= 100L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1901] == 0) {
          {
          fprintf(_coverage_fout, "1901\n");
          fflush(_coverage_fout);
          ___coverage_array[1901] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        yea += 1900L;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1902] == 0) {
          {
          fprintf(_coverage_fout, "1902\n");
          fflush(_coverage_fout);
          ___coverage_array[1902] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1904] == 0) {
        {
        fprintf(_coverage_fout, "1904\n");
        fflush(_coverage_fout);
        ___coverage_array[1904] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1907] == 0) {
    {
    fprintf(_coverage_fout, "1907\n");
    fflush(_coverage_fout);
    ___coverage_array[1907] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  now->y = (long long )yea;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1908] == 0) {
    {
    fprintf(_coverage_fout, "1908\n");
    fflush(_coverage_fout);
    ___coverage_array[1908] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 5: 
  now->d = (long long )day;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1909] == 0) {
    {
    fprintf(_coverage_fout, "1909\n");
    fflush(_coverage_fout);
    ___coverage_array[1909] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 4: 
  now->m = (long long )mon;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1910] == 0) {
    {
    fprintf(_coverage_fout, "1910\n");
    fflush(_coverage_fout);
    ___coverage_array[1910] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  now->s = (long long )sec;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1911] == 0) {
    {
    fprintf(_coverage_fout, "1911\n");
    fflush(_coverage_fout);
    ___coverage_array[1911] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  now->i = (long long )min;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1912] == 0) {
    {
    fprintf(_coverage_fout, "1912\n");
    fflush(_coverage_fout);
    ___coverage_array[1912] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  now->h = (long long )hou;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1913] == 0) {
    {
    fprintf(_coverage_fout, "1913\n");
    fflush(_coverage_fout);
    ___coverage_array[1913] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  php_error_docref0((char const   *)((void *)0), 1 << 11L,
                    "You should be using the time() function instead");
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1956] == 0) {
    {
    fprintf(_coverage_fout, "1956\n");
    fflush(_coverage_fout);
    ___coverage_array[1956] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (gmt) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1914] == 0) {
      {
      fprintf(_coverage_fout, "1914\n");
      fflush(_coverage_fout);
      ___coverage_array[1914] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_update_ts(now, (timelib_tzinfo *)((void *)0));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1915] == 0) {
      {
      fprintf(_coverage_fout, "1915\n");
      fflush(_coverage_fout);
      ___coverage_array[1915] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_update_ts(now, tzi);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1957] == 0) {
    {
    fprintf(_coverage_fout, "1957\n");
    fflush(_coverage_fout);
    ___coverage_array[1957] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (dst != -1L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1931] == 0) {
      {
      fprintf(_coverage_fout, "1931\n");
      fflush(_coverage_fout);
      ___coverage_array[1931] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 13L,
                      "The is_dst parameter is deprecated");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1932] == 0) {
      {
      fprintf(_coverage_fout, "1932\n");
      fflush(_coverage_fout);
      ___coverage_array[1932] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (gmt) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1918] == 0) {
        {
        fprintf(_coverage_fout, "1918\n");
        fflush(_coverage_fout);
        ___coverage_array[1918] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (dst == 1L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1916] == 0) {
          {
          fprintf(_coverage_fout, "1916\n");
          fflush(_coverage_fout);
          ___coverage_array[1916] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        adjust_seconds = -3600L;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1917] == 0) {
          {
          fprintf(_coverage_fout, "1917\n");
          fflush(_coverage_fout);
          ___coverage_array[1917] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1927] == 0) {
        {
        fprintf(_coverage_fout, "1927\n");
        fflush(_coverage_fout);
        ___coverage_array[1927] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp_offset = timelib_get_time_zone_info(now->sse, tzi);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1928] == 0) {
        {
        fprintf(_coverage_fout, "1928\n");
        fflush(_coverage_fout);
        ___coverage_array[1928] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (dst == 1L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1921] == 0) {
          {
          fprintf(_coverage_fout, "1921\n");
          fflush(_coverage_fout);
          ___coverage_array[1921] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp_offset->is_dst == 0U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1919] == 0) {
            {
            fprintf(_coverage_fout, "1919\n");
            fflush(_coverage_fout);
            ___coverage_array[1919] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          adjust_seconds = -3600L;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1920] == 0) {
            {
            fprintf(_coverage_fout, "1920\n");
            fflush(_coverage_fout);
            ___coverage_array[1920] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1922] == 0) {
          {
          fprintf(_coverage_fout, "1922\n");
          fflush(_coverage_fout);
          ___coverage_array[1922] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1929] == 0) {
        {
        fprintf(_coverage_fout, "1929\n");
        fflush(_coverage_fout);
        ___coverage_array[1929] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (dst == 0L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1925] == 0) {
          {
          fprintf(_coverage_fout, "1925\n");
          fflush(_coverage_fout);
          ___coverage_array[1925] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp_offset->is_dst == 1U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1923] == 0) {
            {
            fprintf(_coverage_fout, "1923\n");
            fflush(_coverage_fout);
            ___coverage_array[1923] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          adjust_seconds = 3600L;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1924] == 0) {
            {
            fprintf(_coverage_fout, "1924\n");
            fflush(_coverage_fout);
            ___coverage_array[1924] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1926] == 0) {
          {
          fprintf(_coverage_fout, "1926\n");
          fflush(_coverage_fout);
          ___coverage_array[1926] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1930] == 0) {
        {
        fprintf(_coverage_fout, "1930\n");
        fflush(_coverage_fout);
        ___coverage_array[1930] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_time_offset_dtor(tmp_offset);
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1933] == 0) {
      {
      fprintf(_coverage_fout, "1933\n");
      fflush(_coverage_fout);
      ___coverage_array[1933] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1958] == 0) {
    {
    fprintf(_coverage_fout, "1958\n");
    fflush(_coverage_fout);
    ___coverage_array[1958] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts = timelib_date_to_int(now, & error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1959] == 0) {
    {
    fprintf(_coverage_fout, "1959\n");
    fflush(_coverage_fout);
    ___coverage_array[1959] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts += adjust_seconds;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1960] == 0) {
    {
    fprintf(_coverage_fout, "1960\n");
    fflush(_coverage_fout);
    ___coverage_array[1960] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(now);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1961] == 0) {
    {
    fprintf(_coverage_fout, "1961\n");
    fflush(_coverage_fout);
    ___coverage_array[1961] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (error) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1937] == 0) {
      {
      fprintf(_coverage_fout, "1937\n");
      fflush(_coverage_fout);
      ___coverage_array[1937] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1934] == 0) {
        {
        fprintf(_coverage_fout, "1934\n");
        fflush(_coverage_fout);
        ___coverage_array[1934] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1935] == 0) {
        {
        fprintf(_coverage_fout, "1935\n");
        fflush(_coverage_fout);
        ___coverage_array[1935] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1936] == 0) {
        {
        fprintf(_coverage_fout, "1936\n");
        fflush(_coverage_fout);
        ___coverage_array[1936] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1938] == 0) {
      {
      fprintf(_coverage_fout, "1938\n");
      fflush(_coverage_fout);
      ___coverage_array[1938] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1939] == 0) {
      {
      fprintf(_coverage_fout, "1939\n");
      fflush(_coverage_fout);
      ___coverage_array[1939] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1940] == 0) {
      {
      fprintf(_coverage_fout, "1940\n");
      fflush(_coverage_fout);
      ___coverage_array[1940] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.lval = ts;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1941] == 0) {
      {
      fprintf(_coverage_fout, "1941\n");
      fflush(_coverage_fout);
      ___coverage_array[1941] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1942] == 0) {
      {
      fprintf(_coverage_fout, "1942\n");
      fflush(_coverage_fout);
      ___coverage_array[1942] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
}
}
void zif_mktime(int ht , zval *return_value , zval **return_value_ptr ,
                zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1962] == 0) {
    {
    fprintf(_coverage_fout, "1962\n");
    fflush(_coverage_fout);
    ___coverage_array[1962] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_mktime(ht, return_value, return_value_ptr, this_ptr, return_value_used, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1963] == 0) {
    {
    fprintf(_coverage_fout, "1963\n");
    fflush(_coverage_fout);
    ___coverage_array[1963] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_gmmktime(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1964] == 0) {
    {
    fprintf(_coverage_fout, "1964\n");
    fflush(_coverage_fout);
    ___coverage_array[1964] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_mktime(ht, return_value, return_value_ptr, this_ptr, return_value_used, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1965] == 0) {
    {
    fprintf(_coverage_fout, "1965\n");
    fflush(_coverage_fout);
    ___coverage_array[1965] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_checkdate(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) 
{ long m ;
  long d ;
  long y ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  int tmp___0 ;
  zval *__z___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1984] == 0) {
    {
    fprintf(_coverage_fout, "1984\n");
    fflush(_coverage_fout);
    ___coverage_array[1984] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "lll", & m, & d, & y);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1985] == 0) {
    {
    fprintf(_coverage_fout, "1985\n");
    fflush(_coverage_fout);
    ___coverage_array[1985] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1969] == 0) {
      {
      fprintf(_coverage_fout, "1969\n");
      fflush(_coverage_fout);
      ___coverage_array[1969] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1966] == 0) {
        {
        fprintf(_coverage_fout, "1966\n");
        fflush(_coverage_fout);
        ___coverage_array[1966] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1967] == 0) {
        {
        fprintf(_coverage_fout, "1967\n");
        fflush(_coverage_fout);
        ___coverage_array[1967] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1968] == 0) {
        {
        fprintf(_coverage_fout, "1968\n");
        fflush(_coverage_fout);
        ___coverage_array[1968] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1970] == 0) {
      {
      fprintf(_coverage_fout, "1970\n");
      fflush(_coverage_fout);
      ___coverage_array[1970] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1971] == 0) {
      {
      fprintf(_coverage_fout, "1971\n");
      fflush(_coverage_fout);
      ___coverage_array[1971] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1986] == 0) {
    {
    fprintf(_coverage_fout, "1986\n");
    fflush(_coverage_fout);
    ___coverage_array[1986] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (y < 1L) {
    goto _L;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1980] == 0) {
      {
      fprintf(_coverage_fout, "1980\n");
      fflush(_coverage_fout);
      ___coverage_array[1980] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (y > 32767L) {
      goto _L;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1978] == 0) {
        {
        fprintf(_coverage_fout, "1978\n");
        fflush(_coverage_fout);
        ___coverage_array[1978] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = timelib_valid_date((long long )y, (long long )m, (long long )d);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1979] == 0) {
        {
        fprintf(_coverage_fout, "1979\n");
        fflush(_coverage_fout);
        ___coverage_array[1979] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1972] == 0) {
          {
          fprintf(_coverage_fout, "1972\n");
          fflush(_coverage_fout);
          ___coverage_array[1972] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1976] == 0) {
          {
          fprintf(_coverage_fout, "1976\n");
          fflush(_coverage_fout);
          ___coverage_array[1976] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _L: /* CIL Label */ 
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1973] == 0) {
            {
            fprintf(_coverage_fout, "1973\n");
            fflush(_coverage_fout);
            ___coverage_array[1973] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __z___0 = return_value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1974] == 0) {
            {
            fprintf(_coverage_fout, "1974\n");
            fflush(_coverage_fout);
            ___coverage_array[1974] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __z___0->value.lval = 0L;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[1975] == 0) {
            {
            fprintf(_coverage_fout, "1975\n");
            fflush(_coverage_fout);
            ___coverage_array[1975] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __z___0->type = (unsigned char)3;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[1977] == 0) {
          {
          fprintf(_coverage_fout, "1977\n");
          fflush(_coverage_fout);
          ___coverage_array[1977] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return;
      }
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1987] == 0) {
    {
    fprintf(_coverage_fout, "1987\n");
    fflush(_coverage_fout);
    ___coverage_array[1987] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1981] == 0) {
      {
      fprintf(_coverage_fout, "1981\n");
      fflush(_coverage_fout);
      ___coverage_array[1981] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1982] == 0) {
      {
      fprintf(_coverage_fout, "1982\n");
      fflush(_coverage_fout);
      ___coverage_array[1982] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.lval = 1L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1983] == 0) {
      {
      fprintf(_coverage_fout, "1983\n");
      fflush(_coverage_fout);
      ___coverage_array[1983] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)3;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[1988] == 0) {
    {
    fprintf(_coverage_fout, "1988\n");
    fflush(_coverage_fout);
    ___coverage_array[1988] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void __attribute__((__visibility__("default")))  php_strftime(int ht ,
                                                              zval *return_value ,
                                                              zval **return_value_ptr ,
                                                              zval *this_ptr ,
                                                              int return_value_used ,
                                                              int gmt ) 
{ char *format ;
  char *buf ;
  int format_len ;
  long timestamp ;
  struct tm ta ;
  int max_reallocs ;
  size_t buf_len ;
  size_t real_len ;
  timelib_time *ts ;
  timelib_tzinfo *tzi ;
  timelib_time_offset *offset ;
  time_t tmp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval *__z___0 ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___1 ;
  timelib_sll tmp___2 ;
  timelib_sll tmp___3 ;
  void __attribute__((__visibility__("default")))  *tmp___4 ;
  void __attribute__((__visibility__("default")))  *tmp___5 ;
  void __attribute__((__visibility__("default")))  *tmp___6 ;
  char const   *__s ;
  int __l ;
  zval *__z___1 ;
  char __attribute__((__visibility__("default")))  *tmp___7 ;
  zval *__z___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2044] == 0) {
    {
    fprintf(_coverage_fout, "2044\n");
    fflush(_coverage_fout);
    ___coverage_array[2044] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2045] == 0) {
    {
    fprintf(_coverage_fout, "2045\n");
    fflush(_coverage_fout);
    ___coverage_array[2045] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  max_reallocs = 5;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2046] == 0) {
    {
    fprintf(_coverage_fout, "2046\n");
    fflush(_coverage_fout);
    ___coverage_array[2046] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  buf_len = (size_t )64;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2047] == 0) {
    {
    fprintf(_coverage_fout, "2047\n");
    fflush(_coverage_fout);
    ___coverage_array[2047] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  offset = (timelib_time_offset *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2048] == 0) {
    {
    fprintf(_coverage_fout, "2048\n");
    fflush(_coverage_fout);
    ___coverage_array[2048] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = time((time_t *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2049] == 0) {
    {
    fprintf(_coverage_fout, "2049\n");
    fflush(_coverage_fout);
    ___coverage_array[2049] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2050] == 0) {
    {
    fprintf(_coverage_fout, "2050\n");
    fflush(_coverage_fout);
    ___coverage_array[2050] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_parse_parameters(ht, "s|l", & format, & format_len, & timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2051] == 0) {
    {
    fprintf(_coverage_fout, "2051\n");
    fflush(_coverage_fout);
    ___coverage_array[2051] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1992] == 0) {
      {
      fprintf(_coverage_fout, "1992\n");
      fflush(_coverage_fout);
      ___coverage_array[1992] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1989] == 0) {
        {
        fprintf(_coverage_fout, "1989\n");
        fflush(_coverage_fout);
        ___coverage_array[1989] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1990] == 0) {
        {
        fprintf(_coverage_fout, "1990\n");
        fflush(_coverage_fout);
        ___coverage_array[1990] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1991] == 0) {
        {
        fprintf(_coverage_fout, "1991\n");
        fflush(_coverage_fout);
        ___coverage_array[1991] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1993] == 0) {
      {
      fprintf(_coverage_fout, "1993\n");
      fflush(_coverage_fout);
      ___coverage_array[1993] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1994] == 0) {
      {
      fprintf(_coverage_fout, "1994\n");
      fflush(_coverage_fout);
      ___coverage_array[1994] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2052] == 0) {
    {
    fprintf(_coverage_fout, "2052\n");
    fflush(_coverage_fout);
    ___coverage_array[2052] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (format_len == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1998] == 0) {
      {
      fprintf(_coverage_fout, "1998\n");
      fflush(_coverage_fout);
      ___coverage_array[1998] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1995] == 0) {
        {
        fprintf(_coverage_fout, "1995\n");
        fflush(_coverage_fout);
        ___coverage_array[1995] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1996] == 0) {
        {
        fprintf(_coverage_fout, "1996\n");
        fflush(_coverage_fout);
        ___coverage_array[1996] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[1997] == 0) {
        {
        fprintf(_coverage_fout, "1997\n");
        fflush(_coverage_fout);
        ___coverage_array[1997] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[1999] == 0) {
      {
      fprintf(_coverage_fout, "1999\n");
      fflush(_coverage_fout);
      ___coverage_array[1999] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2000] == 0) {
      {
      fprintf(_coverage_fout, "2000\n");
      fflush(_coverage_fout);
      ___coverage_array[2000] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2053] == 0) {
    {
    fprintf(_coverage_fout, "2053\n");
    fflush(_coverage_fout);
    ___coverage_array[2053] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2054] == 0) {
    {
    fprintf(_coverage_fout, "2054\n");
    fflush(_coverage_fout);
    ___coverage_array[2054] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (gmt) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2001] == 0) {
      {
      fprintf(_coverage_fout, "2001\n");
      fflush(_coverage_fout);
      ___coverage_array[2001] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)((void *)0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2002] == 0) {
      {
      fprintf(_coverage_fout, "2002\n");
      fflush(_coverage_fout);
      ___coverage_array[2002] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2gmt(ts, (long long )timestamp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2003] == 0) {
      {
      fprintf(_coverage_fout, "2003\n");
      fflush(_coverage_fout);
      ___coverage_array[2003] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = get_timezone_info();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2004] == 0) {
      {
      fprintf(_coverage_fout, "2004\n");
      fflush(_coverage_fout);
      ___coverage_array[2004] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzi = (timelib_tzinfo *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2005] == 0) {
      {
      fprintf(_coverage_fout, "2005\n");
      fflush(_coverage_fout);
      ___coverage_array[2005] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ts->tz_info = tzi;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2006] == 0) {
      {
      fprintf(_coverage_fout, "2006\n");
      fflush(_coverage_fout);
      ___coverage_array[2006] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ts->zone_type = 3U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2007] == 0) {
      {
      fprintf(_coverage_fout, "2007\n");
      fflush(_coverage_fout);
      ___coverage_array[2007] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_unixtime2local(ts, (long long )timestamp);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2055] == 0) {
    {
    fprintf(_coverage_fout, "2055\n");
    fflush(_coverage_fout);
    ___coverage_array[2055] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_sec = (int )ts->s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2056] == 0) {
    {
    fprintf(_coverage_fout, "2056\n");
    fflush(_coverage_fout);
    ___coverage_array[2056] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_min = (int )ts->i;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2057] == 0) {
    {
    fprintf(_coverage_fout, "2057\n");
    fflush(_coverage_fout);
    ___coverage_array[2057] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_hour = (int )ts->h;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2058] == 0) {
    {
    fprintf(_coverage_fout, "2058\n");
    fflush(_coverage_fout);
    ___coverage_array[2058] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_mday = (int )ts->d;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2059] == 0) {
    {
    fprintf(_coverage_fout, "2059\n");
    fflush(_coverage_fout);
    ___coverage_array[2059] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_mon = (int )(ts->m - 1LL);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2060] == 0) {
    {
    fprintf(_coverage_fout, "2060\n");
    fflush(_coverage_fout);
    ___coverage_array[2060] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_year = (int )(ts->y - 1900LL);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2061] == 0) {
    {
    fprintf(_coverage_fout, "2061\n");
    fflush(_coverage_fout);
    ___coverage_array[2061] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = timelib_day_of_week(ts->y, ts->m, ts->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2062] == 0) {
    {
    fprintf(_coverage_fout, "2062\n");
    fflush(_coverage_fout);
    ___coverage_array[2062] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_wday = (int )tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2063] == 0) {
    {
    fprintf(_coverage_fout, "2063\n");
    fflush(_coverage_fout);
    ___coverage_array[2063] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = timelib_day_of_year(ts->y, ts->m, ts->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2064] == 0) {
    {
    fprintf(_coverage_fout, "2064\n");
    fflush(_coverage_fout);
    ___coverage_array[2064] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ta.tm_yday = (int )tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2065] == 0) {
    {
    fprintf(_coverage_fout, "2065\n");
    fflush(_coverage_fout);
    ___coverage_array[2065] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (gmt) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2008] == 0) {
      {
      fprintf(_coverage_fout, "2008\n");
      fflush(_coverage_fout);
      ___coverage_array[2008] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ta.tm_isdst = 0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2009] == 0) {
      {
      fprintf(_coverage_fout, "2009\n");
      fflush(_coverage_fout);
      ___coverage_array[2009] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ta.tm_gmtoff = 0L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2010] == 0) {
      {
      fprintf(_coverage_fout, "2010\n");
      fflush(_coverage_fout);
      ___coverage_array[2010] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ta.tm_zone = "GMT";
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2011] == 0) {
      {
      fprintf(_coverage_fout, "2011\n");
      fflush(_coverage_fout);
      ___coverage_array[2011] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    offset = timelib_get_time_zone_info((long long )timestamp, tzi);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2012] == 0) {
      {
      fprintf(_coverage_fout, "2012\n");
      fflush(_coverage_fout);
      ___coverage_array[2012] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ta.tm_isdst = (int )offset->is_dst;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2013] == 0) {
      {
      fprintf(_coverage_fout, "2013\n");
      fflush(_coverage_fout);
      ___coverage_array[2013] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ta.tm_gmtoff = (long )offset->offset;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2014] == 0) {
      {
      fprintf(_coverage_fout, "2014\n");
      fflush(_coverage_fout);
      ___coverage_array[2014] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ta.tm_zone = (char const   *)offset->abbr;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2066] == 0) {
    {
    fprintf(_coverage_fout, "2066\n");
    fflush(_coverage_fout);
    ___coverage_array[2066] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = _emalloc(buf_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2067] == 0) {
    {
    fprintf(_coverage_fout, "2067\n");
    fflush(_coverage_fout);
    ___coverage_array[2067] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  buf = (char *)tmp___4;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2068] == 0) {
    {
    fprintf(_coverage_fout, "2068\n");
    fflush(_coverage_fout);
    ___coverage_array[2068] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2019] == 0) {
      {
      fprintf(_coverage_fout, "2019\n");
      fflush(_coverage_fout);
      ___coverage_array[2019] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    real_len = strftime((char */* __restrict  */)buf, buf_len,
                        (char const   */* __restrict  */)format,
                        (struct tm  const  */* __restrict  */)(& ta));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2020] == 0) {
      {
      fprintf(_coverage_fout, "2020\n");
      fflush(_coverage_fout);
      ___coverage_array[2020] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (real_len == buf_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2015] == 0) {
        {
        fprintf(_coverage_fout, "2015\n");
        fflush(_coverage_fout);
        ___coverage_array[2015] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2017] == 0) {
        {
        fprintf(_coverage_fout, "2017\n");
        fflush(_coverage_fout);
        ___coverage_array[2017] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (real_len == 0U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2016] == 0) {
          {
          fprintf(_coverage_fout, "2016\n");
          fflush(_coverage_fout);
          ___coverage_array[2016] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2021] == 0) {
      {
      fprintf(_coverage_fout, "2021\n");
      fflush(_coverage_fout);
      ___coverage_array[2021] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    buf_len *= 2U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2022] == 0) {
      {
      fprintf(_coverage_fout, "2022\n");
      fflush(_coverage_fout);
      ___coverage_array[2022] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = _erealloc((void *)buf, buf_len, 0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2023] == 0) {
      {
      fprintf(_coverage_fout, "2023\n");
      fflush(_coverage_fout);
      ___coverage_array[2023] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    buf = (char *)tmp___5;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2024] == 0) {
      {
      fprintf(_coverage_fout, "2024\n");
      fflush(_coverage_fout);
      ___coverage_array[2024] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    max_reallocs --;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2025] == 0) {
      {
      fprintf(_coverage_fout, "2025\n");
      fflush(_coverage_fout);
      ___coverage_array[2025] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (max_reallocs) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2018] == 0) {
        {
        fprintf(_coverage_fout, "2018\n");
        fflush(_coverage_fout);
        ___coverage_array[2018] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2069] == 0) {
    {
    fprintf(_coverage_fout, "2069\n");
    fflush(_coverage_fout);
    ___coverage_array[2069] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(ts);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2070] == 0) {
    {
    fprintf(_coverage_fout, "2070\n");
    fflush(_coverage_fout);
    ___coverage_array[2070] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! gmt) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2026] == 0) {
      {
      fprintf(_coverage_fout, "2026\n");
      fflush(_coverage_fout);
      ___coverage_array[2026] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_offset_dtor(offset);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2027] == 0) {
      {
      fprintf(_coverage_fout, "2027\n");
      fflush(_coverage_fout);
      ___coverage_array[2027] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2071] == 0) {
    {
    fprintf(_coverage_fout, "2071\n");
    fflush(_coverage_fout);
    ___coverage_array[2071] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (real_len) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2039] == 0) {
      {
      fprintf(_coverage_fout, "2039\n");
      fflush(_coverage_fout);
      ___coverage_array[2039] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (real_len != buf_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2034] == 0) {
        {
        fprintf(_coverage_fout, "2034\n");
        fflush(_coverage_fout);
        ___coverage_array[2034] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = _erealloc((void *)buf, real_len + 1U, 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2035] == 0) {
        {
        fprintf(_coverage_fout, "2035\n");
        fflush(_coverage_fout);
        ___coverage_array[2035] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      buf = (char *)tmp___6;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2036] == 0) {
        {
        fprintf(_coverage_fout, "2036\n");
        fflush(_coverage_fout);
        ___coverage_array[2036] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2028] == 0) {
          {
          fprintf(_coverage_fout, "2028\n");
          fflush(_coverage_fout);
          ___coverage_array[2028] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __s = (char const   *)buf;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2029] == 0) {
          {
          fprintf(_coverage_fout, "2029\n");
          fflush(_coverage_fout);
          ___coverage_array[2029] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __l = (int )real_len;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2030] == 0) {
          {
          fprintf(_coverage_fout, "2030\n");
          fflush(_coverage_fout);
          ___coverage_array[2030] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1 = return_value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2031] == 0) {
          {
          fprintf(_coverage_fout, "2031\n");
          fflush(_coverage_fout);
          ___coverage_array[2031] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->value.str.len = __l;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2032] == 0) {
          {
          fprintf(_coverage_fout, "2032\n");
          fflush(_coverage_fout);
          ___coverage_array[2032] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2033] == 0) {
          {
          fprintf(_coverage_fout, "2033\n");
          fflush(_coverage_fout);
          ___coverage_array[2033] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->type = (unsigned char)6;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2037] == 0) {
        {
        fprintf(_coverage_fout, "2037\n");
        fflush(_coverage_fout);
        ___coverage_array[2037] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2038] == 0) {
        {
        fprintf(_coverage_fout, "2038\n");
        fflush(_coverage_fout);
        ___coverage_array[2038] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2040] == 0) {
      {
      fprintf(_coverage_fout, "2040\n");
      fflush(_coverage_fout);
      ___coverage_array[2040] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2072] == 0) {
    {
    fprintf(_coverage_fout, "2072\n");
    fflush(_coverage_fout);
    ___coverage_array[2072] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree((void *)buf);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2073] == 0) {
    {
    fprintf(_coverage_fout, "2073\n");
    fflush(_coverage_fout);
    ___coverage_array[2073] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2041] == 0) {
      {
      fprintf(_coverage_fout, "2041\n");
      fflush(_coverage_fout);
      ___coverage_array[2041] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2042] == 0) {
      {
      fprintf(_coverage_fout, "2042\n");
      fflush(_coverage_fout);
      ___coverage_array[2042] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->value.lval = 0L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2043] == 0) {
      {
      fprintf(_coverage_fout, "2043\n");
      fflush(_coverage_fout);
      ___coverage_array[2043] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->type = (unsigned char)3;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2074] == 0) {
    {
    fprintf(_coverage_fout, "2074\n");
    fflush(_coverage_fout);
    ___coverage_array[2074] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_strftime(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2075] == 0) {
    {
    fprintf(_coverage_fout, "2075\n");
    fflush(_coverage_fout);
    ___coverage_array[2075] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_strftime(ht, return_value, return_value_ptr, this_ptr, return_value_used,
               0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2076] == 0) {
    {
    fprintf(_coverage_fout, "2076\n");
    fflush(_coverage_fout);
    ___coverage_array[2076] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_gmstrftime(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2077] == 0) {
    {
    fprintf(_coverage_fout, "2077\n");
    fflush(_coverage_fout);
    ___coverage_array[2077] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_strftime(ht, return_value, return_value_ptr, this_ptr, return_value_used,
               1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2078] == 0) {
    {
    fprintf(_coverage_fout, "2078\n");
    fflush(_coverage_fout);
    ___coverage_array[2078] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_time(int ht , zval *return_value , zval **return_value_ptr ,
              zval *this_ptr , int return_value_used ) 
{ zval *__z ;
  time_t tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2079] == 0) {
    {
    fprintf(_coverage_fout, "2079\n");
    fflush(_coverage_fout);
    ___coverage_array[2079] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z = return_value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2080] == 0) {
    {
    fprintf(_coverage_fout, "2080\n");
    fflush(_coverage_fout);
    ___coverage_array[2080] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = time((time_t *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2081] == 0) {
    {
    fprintf(_coverage_fout, "2081\n");
    fflush(_coverage_fout);
    ___coverage_array[2081] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z->value.lval = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2082] == 0) {
    {
    fprintf(_coverage_fout, "2082\n");
    fflush(_coverage_fout);
    ___coverage_array[2082] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2083] == 0) {
    {
    fprintf(_coverage_fout, "2083\n");
    fflush(_coverage_fout);
    ___coverage_array[2083] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_localtime(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) 
{ long timestamp ;
  time_t tmp ;
  zend_bool associative ;
  timelib_tzinfo *tzi ;
  timelib_time *ts ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  size_t tmp___4 ;
  size_t tmp___5 ;
  size_t tmp___6 ;
  size_t tmp___7 ;
  timelib_sll tmp___8 ;
  size_t tmp___9 ;
  timelib_sll tmp___10 ;
  size_t tmp___11 ;
  size_t tmp___12 ;
  timelib_sll tmp___13 ;
  timelib_sll tmp___14 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2121] == 0) {
    {
    fprintf(_coverage_fout, "2121\n");
    fflush(_coverage_fout);
    ___coverage_array[2121] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = time((time_t *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2122] == 0) {
    {
    fprintf(_coverage_fout, "2122\n");
    fflush(_coverage_fout);
    ___coverage_array[2122] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2123] == 0) {
    {
    fprintf(_coverage_fout, "2123\n");
    fflush(_coverage_fout);
    ___coverage_array[2123] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  associative = (zend_bool )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2124] == 0) {
    {
    fprintf(_coverage_fout, "2124\n");
    fflush(_coverage_fout);
    ___coverage_array[2124] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_parse_parameters(ht, "|lb", & timestamp, & associative);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2125] == 0) {
    {
    fprintf(_coverage_fout, "2125\n");
    fflush(_coverage_fout);
    ___coverage_array[2125] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2087] == 0) {
      {
      fprintf(_coverage_fout, "2087\n");
      fflush(_coverage_fout);
      ___coverage_array[2087] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2084] == 0) {
        {
        fprintf(_coverage_fout, "2084\n");
        fflush(_coverage_fout);
        ___coverage_array[2084] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2085] == 0) {
        {
        fprintf(_coverage_fout, "2085\n");
        fflush(_coverage_fout);
        ___coverage_array[2085] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2086] == 0) {
        {
        fprintf(_coverage_fout, "2086\n");
        fflush(_coverage_fout);
        ___coverage_array[2086] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2088] == 0) {
      {
      fprintf(_coverage_fout, "2088\n");
      fflush(_coverage_fout);
      ___coverage_array[2088] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2089] == 0) {
      {
      fprintf(_coverage_fout, "2089\n");
      fflush(_coverage_fout);
      ___coverage_array[2089] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2126] == 0) {
    {
    fprintf(_coverage_fout, "2126\n");
    fflush(_coverage_fout);
    ___coverage_array[2126] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = get_timezone_info();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2127] == 0) {
    {
    fprintf(_coverage_fout, "2127\n");
    fflush(_coverage_fout);
    ___coverage_array[2127] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2128] == 0) {
    {
    fprintf(_coverage_fout, "2128\n");
    fflush(_coverage_fout);
    ___coverage_array[2128] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2129] == 0) {
    {
    fprintf(_coverage_fout, "2129\n");
    fflush(_coverage_fout);
    ___coverage_array[2129] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts->tz_info = tzi;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2130] == 0) {
    {
    fprintf(_coverage_fout, "2130\n");
    fflush(_coverage_fout);
    ___coverage_array[2130] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts->zone_type = 3U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2131] == 0) {
    {
    fprintf(_coverage_fout, "2131\n");
    fflush(_coverage_fout);
    ___coverage_array[2131] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(ts, (long long )timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2132] == 0) {
    {
    fprintf(_coverage_fout, "2132\n");
    fflush(_coverage_fout);
    ___coverage_array[2132] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2133] == 0) {
    {
    fprintf(_coverage_fout, "2133\n");
    fflush(_coverage_fout);
    ___coverage_array[2133] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (associative) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2090] == 0) {
      {
      fprintf(_coverage_fout, "2090\n");
      fflush(_coverage_fout);
      ___coverage_array[2090] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = strlen("tm_sec");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2091] == 0) {
      {
      fprintf(_coverage_fout, "2091\n");
      fflush(_coverage_fout);
      ___coverage_array[2091] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_sec", tmp___2 + 1U, (long )ts->s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2092] == 0) {
      {
      fprintf(_coverage_fout, "2092\n");
      fflush(_coverage_fout);
      ___coverage_array[2092] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = strlen("tm_min");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2093] == 0) {
      {
      fprintf(_coverage_fout, "2093\n");
      fflush(_coverage_fout);
      ___coverage_array[2093] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_min", tmp___3 + 1U, (long )ts->i);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2094] == 0) {
      {
      fprintf(_coverage_fout, "2094\n");
      fflush(_coverage_fout);
      ___coverage_array[2094] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = strlen("tm_hour");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2095] == 0) {
      {
      fprintf(_coverage_fout, "2095\n");
      fflush(_coverage_fout);
      ___coverage_array[2095] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_hour", tmp___4 + 1U, (long )ts->h);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2096] == 0) {
      {
      fprintf(_coverage_fout, "2096\n");
      fflush(_coverage_fout);
      ___coverage_array[2096] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = strlen("tm_mday");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2097] == 0) {
      {
      fprintf(_coverage_fout, "2097\n");
      fflush(_coverage_fout);
      ___coverage_array[2097] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_mday", tmp___5 + 1U, (long )ts->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2098] == 0) {
      {
      fprintf(_coverage_fout, "2098\n");
      fflush(_coverage_fout);
      ___coverage_array[2098] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = strlen("tm_mon");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2099] == 0) {
      {
      fprintf(_coverage_fout, "2099\n");
      fflush(_coverage_fout);
      ___coverage_array[2099] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_mon", tmp___6 + 1U, (long )(ts->m - 1LL));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2100] == 0) {
      {
      fprintf(_coverage_fout, "2100\n");
      fflush(_coverage_fout);
      ___coverage_array[2100] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = strlen("tm_year");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2101] == 0) {
      {
      fprintf(_coverage_fout, "2101\n");
      fflush(_coverage_fout);
      ___coverage_array[2101] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_year", tmp___7 + 1U,
                      (long )(ts->y - 1900LL));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2102] == 0) {
      {
      fprintf(_coverage_fout, "2102\n");
      fflush(_coverage_fout);
      ___coverage_array[2102] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___8 = timelib_day_of_week(ts->y, ts->m, ts->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2103] == 0) {
      {
      fprintf(_coverage_fout, "2103\n");
      fflush(_coverage_fout);
      ___coverage_array[2103] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = strlen("tm_wday");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2104] == 0) {
      {
      fprintf(_coverage_fout, "2104\n");
      fflush(_coverage_fout);
      ___coverage_array[2104] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_wday", tmp___9 + 1U, (long )tmp___8);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2105] == 0) {
      {
      fprintf(_coverage_fout, "2105\n");
      fflush(_coverage_fout);
      ___coverage_array[2105] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = timelib_day_of_year(ts->y, ts->m, ts->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2106] == 0) {
      {
      fprintf(_coverage_fout, "2106\n");
      fflush(_coverage_fout);
      ___coverage_array[2106] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___11 = strlen("tm_yday");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2107] == 0) {
      {
      fprintf(_coverage_fout, "2107\n");
      fflush(_coverage_fout);
      ___coverage_array[2107] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_yday", tmp___11 + 1U, (long )tmp___10);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2108] == 0) {
      {
      fprintf(_coverage_fout, "2108\n");
      fflush(_coverage_fout);
      ___coverage_array[2108] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___12 = strlen("tm_isdst");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2109] == 0) {
      {
      fprintf(_coverage_fout, "2109\n");
      fflush(_coverage_fout);
      ___coverage_array[2109] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "tm_isdst", tmp___12 + 1U, (long )ts->dst);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2110] == 0) {
      {
      fprintf(_coverage_fout, "2110\n");
      fflush(_coverage_fout);
      ___coverage_array[2110] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )ts->s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2111] == 0) {
      {
      fprintf(_coverage_fout, "2111\n");
      fflush(_coverage_fout);
      ___coverage_array[2111] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )ts->i);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2112] == 0) {
      {
      fprintf(_coverage_fout, "2112\n");
      fflush(_coverage_fout);
      ___coverage_array[2112] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )ts->h);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2113] == 0) {
      {
      fprintf(_coverage_fout, "2113\n");
      fflush(_coverage_fout);
      ___coverage_array[2113] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )ts->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2114] == 0) {
      {
      fprintf(_coverage_fout, "2114\n");
      fflush(_coverage_fout);
      ___coverage_array[2114] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )(ts->m - 1LL));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2115] == 0) {
      {
      fprintf(_coverage_fout, "2115\n");
      fflush(_coverage_fout);
      ___coverage_array[2115] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )(ts->y - 1900LL));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2116] == 0) {
      {
      fprintf(_coverage_fout, "2116\n");
      fflush(_coverage_fout);
      ___coverage_array[2116] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___13 = timelib_day_of_week(ts->y, ts->m, ts->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2117] == 0) {
      {
      fprintf(_coverage_fout, "2117\n");
      fflush(_coverage_fout);
      ___coverage_array[2117] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )tmp___13);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2118] == 0) {
      {
      fprintf(_coverage_fout, "2118\n");
      fflush(_coverage_fout);
      ___coverage_array[2118] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___14 = timelib_day_of_year(ts->y, ts->m, ts->d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2119] == 0) {
      {
      fprintf(_coverage_fout, "2119\n");
      fflush(_coverage_fout);
      ___coverage_array[2119] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )tmp___14);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2120] == 0) {
      {
      fprintf(_coverage_fout, "2120\n");
      fflush(_coverage_fout);
      ___coverage_array[2120] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_long(return_value, (long )ts->dst);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2134] == 0) {
    {
    fprintf(_coverage_fout, "2134\n");
    fflush(_coverage_fout);
    ___coverage_array[2134] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(ts);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2135] == 0) {
    {
    fprintf(_coverage_fout, "2135\n");
    fflush(_coverage_fout);
    ___coverage_array[2135] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_getdate(int ht , zval *return_value , zval **return_value_ptr ,
                 zval *this_ptr , int return_value_used ) 
{ long timestamp ;
  time_t tmp ;
  timelib_tzinfo *tzi ;
  timelib_time *ts ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  size_t tmp___4 ;
  size_t tmp___5 ;
  timelib_sll tmp___6 ;
  size_t tmp___7 ;
  size_t tmp___8 ;
  size_t tmp___9 ;
  timelib_sll tmp___10 ;
  size_t tmp___11 ;
  char *tmp___12 ;
  size_t tmp___13 ;
  size_t tmp___14 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2142] == 0) {
    {
    fprintf(_coverage_fout, "2142\n");
    fflush(_coverage_fout);
    ___coverage_array[2142] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = time((time_t *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2143] == 0) {
    {
    fprintf(_coverage_fout, "2143\n");
    fflush(_coverage_fout);
    ___coverage_array[2143] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp = tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2144] == 0) {
    {
    fprintf(_coverage_fout, "2144\n");
    fflush(_coverage_fout);
    ___coverage_array[2144] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_parse_parameters(ht, "|l", & timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2145] == 0) {
    {
    fprintf(_coverage_fout, "2145\n");
    fflush(_coverage_fout);
    ___coverage_array[2145] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2139] == 0) {
      {
      fprintf(_coverage_fout, "2139\n");
      fflush(_coverage_fout);
      ___coverage_array[2139] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2136] == 0) {
        {
        fprintf(_coverage_fout, "2136\n");
        fflush(_coverage_fout);
        ___coverage_array[2136] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2137] == 0) {
        {
        fprintf(_coverage_fout, "2137\n");
        fflush(_coverage_fout);
        ___coverage_array[2137] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2138] == 0) {
        {
        fprintf(_coverage_fout, "2138\n");
        fflush(_coverage_fout);
        ___coverage_array[2138] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2140] == 0) {
      {
      fprintf(_coverage_fout, "2140\n");
      fflush(_coverage_fout);
      ___coverage_array[2140] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2141] == 0) {
      {
      fprintf(_coverage_fout, "2141\n");
      fflush(_coverage_fout);
      ___coverage_array[2141] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2146] == 0) {
    {
    fprintf(_coverage_fout, "2146\n");
    fflush(_coverage_fout);
    ___coverage_array[2146] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = get_timezone_info();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2147] == 0) {
    {
    fprintf(_coverage_fout, "2147\n");
    fflush(_coverage_fout);
    ___coverage_array[2147] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2148] == 0) {
    {
    fprintf(_coverage_fout, "2148\n");
    fflush(_coverage_fout);
    ___coverage_array[2148] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2149] == 0) {
    {
    fprintf(_coverage_fout, "2149\n");
    fflush(_coverage_fout);
    ___coverage_array[2149] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts->tz_info = tzi;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2150] == 0) {
    {
    fprintf(_coverage_fout, "2150\n");
    fflush(_coverage_fout);
    ___coverage_array[2150] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ts->zone_type = 3U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2151] == 0) {
    {
    fprintf(_coverage_fout, "2151\n");
    fflush(_coverage_fout);
    ___coverage_array[2151] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(ts, (long long )timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2152] == 0) {
    {
    fprintf(_coverage_fout, "2152\n");
    fflush(_coverage_fout);
    ___coverage_array[2152] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2153] == 0) {
    {
    fprintf(_coverage_fout, "2153\n");
    fflush(_coverage_fout);
    ___coverage_array[2153] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = strlen("seconds");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2154] == 0) {
    {
    fprintf(_coverage_fout, "2154\n");
    fflush(_coverage_fout);
    ___coverage_array[2154] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "seconds", tmp___2 + 1U, (long )ts->s);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2155] == 0) {
    {
    fprintf(_coverage_fout, "2155\n");
    fflush(_coverage_fout);
    ___coverage_array[2155] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = strlen("minutes");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2156] == 0) {
    {
    fprintf(_coverage_fout, "2156\n");
    fflush(_coverage_fout);
    ___coverage_array[2156] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "minutes", tmp___3 + 1U, (long )ts->i);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2157] == 0) {
    {
    fprintf(_coverage_fout, "2157\n");
    fflush(_coverage_fout);
    ___coverage_array[2157] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = strlen("hours");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2158] == 0) {
    {
    fprintf(_coverage_fout, "2158\n");
    fflush(_coverage_fout);
    ___coverage_array[2158] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "hours", tmp___4 + 1U, (long )ts->h);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2159] == 0) {
    {
    fprintf(_coverage_fout, "2159\n");
    fflush(_coverage_fout);
    ___coverage_array[2159] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = strlen("mday");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2160] == 0) {
    {
    fprintf(_coverage_fout, "2160\n");
    fflush(_coverage_fout);
    ___coverage_array[2160] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "mday", tmp___5 + 1U, (long )ts->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2161] == 0) {
    {
    fprintf(_coverage_fout, "2161\n");
    fflush(_coverage_fout);
    ___coverage_array[2161] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___6 = timelib_day_of_week(ts->y, ts->m, ts->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2162] == 0) {
    {
    fprintf(_coverage_fout, "2162\n");
    fflush(_coverage_fout);
    ___coverage_array[2162] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___7 = strlen("wday");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2163] == 0) {
    {
    fprintf(_coverage_fout, "2163\n");
    fflush(_coverage_fout);
    ___coverage_array[2163] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "wday", tmp___7 + 1U, (long )tmp___6);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2164] == 0) {
    {
    fprintf(_coverage_fout, "2164\n");
    fflush(_coverage_fout);
    ___coverage_array[2164] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___8 = strlen("mon");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2165] == 0) {
    {
    fprintf(_coverage_fout, "2165\n");
    fflush(_coverage_fout);
    ___coverage_array[2165] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "mon", tmp___8 + 1U, (long )ts->m);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2166] == 0) {
    {
    fprintf(_coverage_fout, "2166\n");
    fflush(_coverage_fout);
    ___coverage_array[2166] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___9 = strlen("year");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2167] == 0) {
    {
    fprintf(_coverage_fout, "2167\n");
    fflush(_coverage_fout);
    ___coverage_array[2167] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "year", tmp___9 + 1U, (long )ts->y);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2168] == 0) {
    {
    fprintf(_coverage_fout, "2168\n");
    fflush(_coverage_fout);
    ___coverage_array[2168] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___10 = timelib_day_of_year(ts->y, ts->m, ts->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2169] == 0) {
    {
    fprintf(_coverage_fout, "2169\n");
    fflush(_coverage_fout);
    ___coverage_array[2169] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___11 = strlen("yday");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2170] == 0) {
    {
    fprintf(_coverage_fout, "2170\n");
    fflush(_coverage_fout);
    ___coverage_array[2170] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "yday", tmp___11 + 1U, (long )tmp___10);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2171] == 0) {
    {
    fprintf(_coverage_fout, "2171\n");
    fflush(_coverage_fout);
    ___coverage_array[2171] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___12 = php_date_full_day_name(ts->y, ts->m, ts->d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2172] == 0) {
    {
    fprintf(_coverage_fout, "2172\n");
    fflush(_coverage_fout);
    ___coverage_array[2172] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___13 = strlen("weekday");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2173] == 0) {
    {
    fprintf(_coverage_fout, "2173\n");
    fflush(_coverage_fout);
    ___coverage_array[2173] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_string_ex(return_value, "weekday", tmp___13 + 1U, tmp___12, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2174] == 0) {
    {
    fprintf(_coverage_fout, "2174\n");
    fflush(_coverage_fout);
    ___coverage_array[2174] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___14 = strlen("month");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2175] == 0) {
    {
    fprintf(_coverage_fout, "2175\n");
    fflush(_coverage_fout);
    ___coverage_array[2175] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_string_ex(return_value, "month", tmp___14 + 1U,
                      mon_full_names[ts->m - 1LL], 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2176] == 0) {
    {
    fprintf(_coverage_fout, "2176\n");
    fflush(_coverage_fout);
    ___coverage_array[2176] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_index_long(return_value, 0UL, timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2177] == 0) {
    {
    fprintf(_coverage_fout, "2177\n");
    fflush(_coverage_fout);
    ___coverage_array[2177] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(ts);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2178] == 0) {
    {
    fprintf(_coverage_fout, "2178\n");
    fflush(_coverage_fout);
    ___coverage_array[2178] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void date_period_it_invalidate_current(zend_object_iterator *iter ) 
{ date_period_it *iterator ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2182] == 0) {
    {
    fprintf(_coverage_fout, "2182\n");
    fflush(_coverage_fout);
    ___coverage_array[2182] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2183] == 0) {
    {
    fprintf(_coverage_fout, "2183\n");
    fflush(_coverage_fout);
    ___coverage_array[2183] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (iterator->current) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2179] == 0) {
      {
      fprintf(_coverage_fout, "2179\n");
      fflush(_coverage_fout);
      ___coverage_array[2179] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_ptr_dtor(& iterator->current);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2180] == 0) {
      {
      fprintf(_coverage_fout, "2180\n");
      fflush(_coverage_fout);
      ___coverage_array[2180] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    iterator->current = (zval *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2181] == 0) {
      {
      fprintf(_coverage_fout, "2181\n");
      fflush(_coverage_fout);
      ___coverage_array[2181] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2184] == 0) {
    {
    fprintf(_coverage_fout, "2184\n");
    fflush(_coverage_fout);
    ___coverage_array[2184] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void date_period_it_dtor(zend_object_iterator *iter ) 
{ date_period_it *iterator ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2185] == 0) {
    {
    fprintf(_coverage_fout, "2185\n");
    fflush(_coverage_fout);
    ___coverage_array[2185] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2186] == 0) {
    {
    fprintf(_coverage_fout, "2186\n");
    fflush(_coverage_fout);
    ___coverage_array[2186] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_period_it_invalidate_current(iter);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2187] == 0) {
    {
    fprintf(_coverage_fout, "2187\n");
    fflush(_coverage_fout);
    ___coverage_array[2187] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_ptr_dtor(& iterator->date_period_zval);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2188] == 0) {
    {
    fprintf(_coverage_fout, "2188\n");
    fflush(_coverage_fout);
    ___coverage_array[2188] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree((void *)iterator);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2189] == 0) {
    {
    fprintf(_coverage_fout, "2189\n");
    fflush(_coverage_fout);
    ___coverage_array[2189] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int date_period_it_has_more(zend_object_iterator *iter ) 
{ date_period_it *iterator ;
  php_period_obj *object ;
  timelib_time *it_time ;
  int tmp ;
  int tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2210] == 0) {
    {
    fprintf(_coverage_fout, "2210\n");
    fflush(_coverage_fout);
    ___coverage_array[2210] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2211] == 0) {
    {
    fprintf(_coverage_fout, "2211\n");
    fflush(_coverage_fout);
    ___coverage_array[2211] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object = iterator->object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2212] == 0) {
    {
    fprintf(_coverage_fout, "2212\n");
    fflush(_coverage_fout);
    ___coverage_array[2212] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  it_time = object->current;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2213] == 0) {
    {
    fprintf(_coverage_fout, "2213\n");
    fflush(_coverage_fout);
    ___coverage_array[2213] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! object->include_start_date) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2190] == 0) {
      {
      fprintf(_coverage_fout, "2190\n");
      fflush(_coverage_fout);
      ___coverage_array[2190] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    it_time->have_relative = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2191] == 0) {
      {
      fprintf(_coverage_fout, "2191\n");
      fflush(_coverage_fout);
      ___coverage_array[2191] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    it_time->relative = *(object->interval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2192] == 0) {
      {
      fprintf(_coverage_fout, "2192\n");
      fflush(_coverage_fout);
      ___coverage_array[2192] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    it_time->sse_uptodate = 0U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2193] == 0) {
      {
      fprintf(_coverage_fout, "2193\n");
      fflush(_coverage_fout);
      ___coverage_array[2193] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_update_ts(it_time, (timelib_tzinfo *)((void *)0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2194] == 0) {
      {
      fprintf(_coverage_fout, "2194\n");
      fflush(_coverage_fout);
      ___coverage_array[2194] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_update_from_sse(it_time);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2201] == 0) {
      {
      fprintf(_coverage_fout, "2201\n");
      fflush(_coverage_fout);
      ___coverage_array[2201] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (iterator->current_index > 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2195] == 0) {
        {
        fprintf(_coverage_fout, "2195\n");
        fflush(_coverage_fout);
        ___coverage_array[2195] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      it_time->have_relative = 1U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2196] == 0) {
        {
        fprintf(_coverage_fout, "2196\n");
        fflush(_coverage_fout);
        ___coverage_array[2196] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      it_time->relative = *(object->interval);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2197] == 0) {
        {
        fprintf(_coverage_fout, "2197\n");
        fflush(_coverage_fout);
        ___coverage_array[2197] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      it_time->sse_uptodate = 0U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2198] == 0) {
        {
        fprintf(_coverage_fout, "2198\n");
        fflush(_coverage_fout);
        ___coverage_array[2198] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_update_ts(it_time, (timelib_tzinfo *)((void *)0));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2199] == 0) {
        {
        fprintf(_coverage_fout, "2199\n");
        fflush(_coverage_fout);
        ___coverage_array[2199] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_update_from_sse(it_time);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2200] == 0) {
        {
        fprintf(_coverage_fout, "2200\n");
        fflush(_coverage_fout);
        ___coverage_array[2200] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2214] == 0) {
    {
    fprintf(_coverage_fout, "2214\n");
    fflush(_coverage_fout);
    ___coverage_array[2214] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (object->end) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2204] == 0) {
      {
      fprintf(_coverage_fout, "2204\n");
      fflush(_coverage_fout);
      ___coverage_array[2204] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((object->current)->sse < (object->end)->sse) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2202] == 0) {
        {
        fprintf(_coverage_fout, "2202\n");
        fflush(_coverage_fout);
        ___coverage_array[2202] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = 0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2203] == 0) {
        {
        fprintf(_coverage_fout, "2203\n");
        fflush(_coverage_fout);
        ___coverage_array[2203] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = -1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2205] == 0) {
      {
      fprintf(_coverage_fout, "2205\n");
      fflush(_coverage_fout);
      ___coverage_array[2205] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2208] == 0) {
      {
      fprintf(_coverage_fout, "2208\n");
      fflush(_coverage_fout);
      ___coverage_array[2208] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (iterator->current_index < object->recurrences) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2206] == 0) {
        {
        fprintf(_coverage_fout, "2206\n");
        fflush(_coverage_fout);
        ___coverage_array[2206] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = 0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2207] == 0) {
        {
        fprintf(_coverage_fout, "2207\n");
        fflush(_coverage_fout);
        ___coverage_array[2207] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = -1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2209] == 0) {
      {
      fprintf(_coverage_fout, "2209\n");
      fflush(_coverage_fout);
      ___coverage_array[2209] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (tmp___0);
  }
}
}
static void date_period_it_current_data(zend_object_iterator *iter ,
                                        zval ***data ) 
{ date_period_it *iterator ;
  php_period_obj *object ;
  timelib_time *it_time ;
  php_date_obj *newdateobj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  size_t __len ;
  size_t tmp___2 ;
  char *__retval ;
  void *tmp___3 ;
  void *tmp___4 ;
  char *tmp___5 ;
  char *tmp___6 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2223] == 0) {
    {
    fprintf(_coverage_fout, "2223\n");
    fflush(_coverage_fout);
    ___coverage_array[2223] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2224] == 0) {
    {
    fprintf(_coverage_fout, "2224\n");
    fflush(_coverage_fout);
    ___coverage_array[2224] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object = iterator->object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2225] == 0) {
    {
    fprintf(_coverage_fout, "2225\n");
    fflush(_coverage_fout);
    ___coverage_array[2225] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  it_time = object->current;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2226] == 0) {
    {
    fprintf(_coverage_fout, "2226\n");
    fflush(_coverage_fout);
    ___coverage_array[2226] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2215] == 0) {
      {
      fprintf(_coverage_fout, "2215\n");
      fflush(_coverage_fout);
      ___coverage_array[2215] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2216] == 0) {
      {
      fprintf(_coverage_fout, "2216\n");
      fflush(_coverage_fout);
      ___coverage_array[2216] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    iterator->current = (zval *)tmp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2217] == 0) {
      {
      fprintf(_coverage_fout, "2217\n");
      fflush(_coverage_fout);
      ___coverage_array[2217] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)iterator->current)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2227] == 0) {
    {
    fprintf(_coverage_fout, "2227\n");
    fflush(_coverage_fout);
    ___coverage_array[2227] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (iterator->current)->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2228] == 0) {
    {
    fprintf(_coverage_fout, "2228\n");
    fflush(_coverage_fout);
    ___coverage_array[2228] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (iterator->current)->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2229] == 0) {
    {
    fprintf(_coverage_fout, "2229\n");
    fflush(_coverage_fout);
    ___coverage_array[2229] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_instantiate(date_ce_date, iterator->current);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2230] == 0) {
    {
    fprintf(_coverage_fout, "2230\n");
    fflush(_coverage_fout);
    ___coverage_array[2230] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)iterator->current);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2231] == 0) {
    {
    fprintf(_coverage_fout, "2231\n");
    fflush(_coverage_fout);
    ___coverage_array[2231] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  newdateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2232] == 0) {
    {
    fprintf(_coverage_fout, "2232\n");
    fflush(_coverage_fout);
    ___coverage_array[2232] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  newdateobj->time = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2233] == 0) {
    {
    fprintf(_coverage_fout, "2233\n");
    fflush(_coverage_fout);
    ___coverage_array[2233] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *(newdateobj->time) = *it_time;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2234] == 0) {
    {
    fprintf(_coverage_fout, "2234\n");
    fflush(_coverage_fout);
    ___coverage_array[2234] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (it_time->tz_abbr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2218] == 0) {
      {
      fprintf(_coverage_fout, "2218\n");
      fflush(_coverage_fout);
      ___coverage_array[2218] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = __strdup((char const   *)it_time->tz_abbr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2219] == 0) {
      {
      fprintf(_coverage_fout, "2219\n");
      fflush(_coverage_fout);
      ___coverage_array[2219] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (newdateobj->time)->tz_abbr = tmp___6;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2220] == 0) {
      {
      fprintf(_coverage_fout, "2220\n");
      fflush(_coverage_fout);
      ___coverage_array[2220] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2235] == 0) {
    {
    fprintf(_coverage_fout, "2235\n");
    fflush(_coverage_fout);
    ___coverage_array[2235] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (it_time->tz_info) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2221] == 0) {
      {
      fprintf(_coverage_fout, "2221\n");
      fflush(_coverage_fout);
      ___coverage_array[2221] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (newdateobj->time)->tz_info = it_time->tz_info;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2222] == 0) {
      {
      fprintf(_coverage_fout, "2222\n");
      fflush(_coverage_fout);
      ___coverage_array[2222] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2236] == 0) {
    {
    fprintf(_coverage_fout, "2236\n");
    fflush(_coverage_fout);
    ___coverage_array[2236] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *data = & iterator->current;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2237] == 0) {
    {
    fprintf(_coverage_fout, "2237\n");
    fflush(_coverage_fout);
    ___coverage_array[2237] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int date_period_it_current_key(zend_object_iterator *iter ,
                                      char **str_key , uint *str_key_len ,
                                      ulong *int_key ) 
{ date_period_it *iterator ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2238] == 0) {
    {
    fprintf(_coverage_fout, "2238\n");
    fflush(_coverage_fout);
    ___coverage_array[2238] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2239] == 0) {
    {
    fprintf(_coverage_fout, "2239\n");
    fflush(_coverage_fout);
    ___coverage_array[2239] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *int_key = (unsigned long )iterator->current_index;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2240] == 0) {
    {
    fprintf(_coverage_fout, "2240\n");
    fflush(_coverage_fout);
    ___coverage_array[2240] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (2);
}
}
static void date_period_it_move_forward(zend_object_iterator *iter ) 
{ date_period_it *iterator ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2241] == 0) {
    {
    fprintf(_coverage_fout, "2241\n");
    fflush(_coverage_fout);
    ___coverage_array[2241] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2242] == 0) {
    {
    fprintf(_coverage_fout, "2242\n");
    fflush(_coverage_fout);
    ___coverage_array[2242] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (iterator->current_index) ++;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2243] == 0) {
    {
    fprintf(_coverage_fout, "2243\n");
    fflush(_coverage_fout);
    ___coverage_array[2243] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_period_it_invalidate_current(iter);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2244] == 0) {
    {
    fprintf(_coverage_fout, "2244\n");
    fflush(_coverage_fout);
    ___coverage_array[2244] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void date_period_it_rewind(zend_object_iterator *iter ) 
{ date_period_it *iterator ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2247] == 0) {
    {
    fprintf(_coverage_fout, "2247\n");
    fflush(_coverage_fout);
    ___coverage_array[2247] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)iter;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2248] == 0) {
    {
    fprintf(_coverage_fout, "2248\n");
    fflush(_coverage_fout);
    ___coverage_array[2248] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator->current_index = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2249] == 0) {
    {
    fprintf(_coverage_fout, "2249\n");
    fflush(_coverage_fout);
    ___coverage_array[2249] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((iterator->object)->current) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2245] == 0) {
      {
      fprintf(_coverage_fout, "2245\n");
      fflush(_coverage_fout);
      ___coverage_array[2245] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor((iterator->object)->current);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2246] == 0) {
      {
      fprintf(_coverage_fout, "2246\n");
      fflush(_coverage_fout);
      ___coverage_array[2246] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2250] == 0) {
    {
    fprintf(_coverage_fout, "2250\n");
    fflush(_coverage_fout);
    ___coverage_array[2250] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (iterator->object)->current = timelib_time_clone((iterator->object)->start);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2251] == 0) {
    {
    fprintf(_coverage_fout, "2251\n");
    fflush(_coverage_fout);
    ___coverage_array[2251] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_period_it_invalidate_current(iter);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2252] == 0) {
    {
    fprintf(_coverage_fout, "2252\n");
    fflush(_coverage_fout);
    ___coverage_array[2252] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
zend_object_iterator_funcs date_period_it_funcs  =    {& date_period_it_dtor, & date_period_it_has_more,
    & date_period_it_current_data, & date_period_it_current_key,
    & date_period_it_move_forward, & date_period_it_rewind,
    & date_period_it_invalidate_current};
zend_object_iterator *date_object_period_get_iterator(zend_class_entry *ce ,
                                                      zval *object , int by_ref ) 
{ date_period_it *iterator ;
  void __attribute__((__visibility__("default")))  *tmp ;
  php_period_obj *dpobj ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2255] == 0) {
    {
    fprintf(_coverage_fout, "2255\n");
    fflush(_coverage_fout);
    ___coverage_array[2255] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(date_period_it ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2256] == 0) {
    {
    fprintf(_coverage_fout, "2256\n");
    fflush(_coverage_fout);
    ___coverage_array[2256] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator = (date_period_it *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2257] == 0) {
    {
    fprintf(_coverage_fout, "2257\n");
    fflush(_coverage_fout);
    ___coverage_array[2257] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2258] == 0) {
    {
    fprintf(_coverage_fout, "2258\n");
    fflush(_coverage_fout);
    ___coverage_array[2258] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dpobj = (php_period_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2259] == 0) {
    {
    fprintf(_coverage_fout, "2259\n");
    fflush(_coverage_fout);
    ___coverage_array[2259] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (by_ref) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2253] == 0) {
      {
      fprintf(_coverage_fout, "2253\n");
      fflush(_coverage_fout);
      ___coverage_array[2253] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zend_error(1, "An iterator cannot be used with foreach by reference");
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2254] == 0) {
      {
      fprintf(_coverage_fout, "2254\n");
      fflush(_coverage_fout);
      ___coverage_array[2254] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2260] == 0) {
    {
    fprintf(_coverage_fout, "2260\n");
    fflush(_coverage_fout);
    ___coverage_array[2260] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_addref_p(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2261] == 0) {
    {
    fprintf(_coverage_fout, "2261\n");
    fflush(_coverage_fout);
    ___coverage_array[2261] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator->intern.data = (void *)dpobj;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2262] == 0) {
    {
    fprintf(_coverage_fout, "2262\n");
    fflush(_coverage_fout);
    ___coverage_array[2262] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator->intern.funcs = & date_period_it_funcs;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2263] == 0) {
    {
    fprintf(_coverage_fout, "2263\n");
    fflush(_coverage_fout);
    ___coverage_array[2263] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator->date_period_zval = object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2264] == 0) {
    {
    fprintf(_coverage_fout, "2264\n");
    fflush(_coverage_fout);
    ___coverage_array[2264] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator->object = dpobj;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2265] == 0) {
    {
    fprintf(_coverage_fout, "2265\n");
    fflush(_coverage_fout);
    ___coverage_array[2265] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  iterator->current = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2266] == 0) {
    {
    fprintf(_coverage_fout, "2266\n");
    fflush(_coverage_fout);
    ___coverage_array[2266] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zend_object_iterator *)iterator);
}
}
static void date_register_classes(void) 
{ zend_class_entry ce_date ;
  zend_class_entry ce_timezone ;
  zend_class_entry ce_interval ;
  zend_class_entry ce_period ;
  char const   *cl_name ;
  int _len ;
  char const __attribute__((__visibility__("default")))  *tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_object_handlers __attribute__((__visibility__("default")))  *tmp___2 ;
  char const   *cl_name___0 ;
  int _len___0 ;
  char const __attribute__((__visibility__("default")))  *tmp___3 ;
  char __attribute__((__visibility__("default")))  *tmp___4 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___5 ;
  zend_object_handlers __attribute__((__visibility__("default")))  *tmp___6 ;
  char const   *cl_name___1 ;
  int _len___1 ;
  char const __attribute__((__visibility__("default")))  *tmp___7 ;
  char __attribute__((__visibility__("default")))  *tmp___8 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___9 ;
  zend_object_handlers __attribute__((__visibility__("default")))  *tmp___10 ;
  char const   *cl_name___2 ;
  int _len___2 ;
  char const __attribute__((__visibility__("default")))  *tmp___11 ;
  char __attribute__((__visibility__("default")))  *tmp___12 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___13 ;
  zend_object_handlers __attribute__((__visibility__("default")))  *tmp___14 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2279] == 0) {
    {
    fprintf(_coverage_fout, "2279\n");
    fflush(_coverage_fout);
    ___coverage_array[2279] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  cl_name = "DateTime";
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2280] == 0) {
    {
    fprintf(_coverage_fout, "2280\n");
    fflush(_coverage_fout);
    ___coverage_array[2280] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _len = (int )(sizeof("DateTime") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2281] == 0) {
    {
    fprintf(_coverage_fout, "2281\n");
    fflush(_coverage_fout);
    ___coverage_array[2281] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = (*zend_new_interned_string)(cl_name, _len + 1, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2282] == 0) {
    {
    fprintf(_coverage_fout, "2282\n");
    fflush(_coverage_fout);
    ___coverage_array[2282] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.name = (char const   *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2283] == 0) {
    {
    fprintf(_coverage_fout, "2283\n");
    fflush(_coverage_fout);
    ___coverage_array[2283] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )ce_date.name == (unsigned int )cl_name) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2267] == 0) {
      {
      fprintf(_coverage_fout, "2267\n");
      fflush(_coverage_fout);
      ___coverage_array[2267] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = zend_strndup(cl_name, (unsigned int )_len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2268] == 0) {
      {
      fprintf(_coverage_fout, "2268\n");
      fflush(_coverage_fout);
      ___coverage_array[2268] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce_date.name = (char const   *)tmp___0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2269] == 0) {
      {
      fprintf(_coverage_fout, "2269\n");
      fflush(_coverage_fout);
      ___coverage_array[2269] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2284] == 0) {
    {
    fprintf(_coverage_fout, "2284\n");
    fflush(_coverage_fout);
    ___coverage_array[2284] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.name_length = (unsigned int )_len;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2285] == 0) {
    {
    fprintf(_coverage_fout, "2285\n");
    fflush(_coverage_fout);
    ___coverage_array[2285] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.constructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2286] == 0) {
    {
    fprintf(_coverage_fout, "2286\n");
    fflush(_coverage_fout);
    ___coverage_array[2286] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.destructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2287] == 0) {
    {
    fprintf(_coverage_fout, "2287\n");
    fflush(_coverage_fout);
    ___coverage_array[2287] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.clone = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2288] == 0) {
    {
    fprintf(_coverage_fout, "2288\n");
    fflush(_coverage_fout);
    ___coverage_array[2288] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.serialize = (int (*)(zval *object , unsigned char **buffer ,
                               zend_uint *buf_len , zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2289] == 0) {
    {
    fprintf(_coverage_fout, "2289\n");
    fflush(_coverage_fout);
    ___coverage_array[2289] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                 unsigned char const   *buf ,
                                 zend_uint buf_len ,
                                 zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2290] == 0) {
    {
    fprintf(_coverage_fout, "2290\n");
    fflush(_coverage_fout);
    ___coverage_array[2290] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.create_object = (zend_object_value (*)(zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2291] == 0) {
    {
    fprintf(_coverage_fout, "2291\n");
    fflush(_coverage_fout);
    ___coverage_array[2291] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.interface_gets_implemented = (int (*)(zend_class_entry *iface ,
                                                zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2292] == 0) {
    {
    fprintf(_coverage_fout, "2292\n");
    fflush(_coverage_fout);
    ___coverage_array[2292] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.get_static_method = (union _zend_function *(*)(zend_class_entry *ce ,
                                                         char *method ,
                                                         int method_len ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2293] == 0) {
    {
    fprintf(_coverage_fout, "2293\n");
    fflush(_coverage_fout);
    ___coverage_array[2293] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__call = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2294] == 0) {
    {
    fprintf(_coverage_fout, "2294\n");
    fflush(_coverage_fout);
    ___coverage_array[2294] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__callstatic = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2295] == 0) {
    {
    fprintf(_coverage_fout, "2295\n");
    fflush(_coverage_fout);
    ___coverage_array[2295] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__tostring = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2296] == 0) {
    {
    fprintf(_coverage_fout, "2296\n");
    fflush(_coverage_fout);
    ___coverage_array[2296] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__get = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2297] == 0) {
    {
    fprintf(_coverage_fout, "2297\n");
    fflush(_coverage_fout);
    ___coverage_array[2297] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__set = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2298] == 0) {
    {
    fprintf(_coverage_fout, "2298\n");
    fflush(_coverage_fout);
    ___coverage_array[2298] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__unset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2299] == 0) {
    {
    fprintf(_coverage_fout, "2299\n");
    fflush(_coverage_fout);
    ___coverage_array[2299] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.__isset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2300] == 0) {
    {
    fprintf(_coverage_fout, "2300\n");
    fflush(_coverage_fout);
    ___coverage_array[2300] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.serialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2301] == 0) {
    {
    fprintf(_coverage_fout, "2301\n");
    fflush(_coverage_fout);
    ___coverage_array[2301] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.unserialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2302] == 0) {
    {
    fprintf(_coverage_fout, "2302\n");
    fflush(_coverage_fout);
    ___coverage_array[2302] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.serialize = (int (*)(zval *object , unsigned char **buffer ,
                               zend_uint *buf_len , zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2303] == 0) {
    {
    fprintf(_coverage_fout, "2303\n");
    fflush(_coverage_fout);
    ___coverage_array[2303] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                 unsigned char const   *buf ,
                                 zend_uint buf_len ,
                                 zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2304] == 0) {
    {
    fprintf(_coverage_fout, "2304\n");
    fflush(_coverage_fout);
    ___coverage_array[2304] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.parent = (struct _zend_class_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2305] == 0) {
    {
    fprintf(_coverage_fout, "2305\n");
    fflush(_coverage_fout);
    ___coverage_array[2305] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.num_interfaces = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2306] == 0) {
    {
    fprintf(_coverage_fout, "2306\n");
    fflush(_coverage_fout);
    ___coverage_array[2306] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.traits = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2307] == 0) {
    {
    fprintf(_coverage_fout, "2307\n");
    fflush(_coverage_fout);
    ___coverage_array[2307] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.num_traits = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2308] == 0) {
    {
    fprintf(_coverage_fout, "2308\n");
    fflush(_coverage_fout);
    ___coverage_array[2308] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.trait_aliases = (zend_trait_alias **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2309] == 0) {
    {
    fprintf(_coverage_fout, "2309\n");
    fflush(_coverage_fout);
    ___coverage_array[2309] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.trait_precedences = (zend_trait_precedence **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2310] == 0) {
    {
    fprintf(_coverage_fout, "2310\n");
    fflush(_coverage_fout);
    ___coverage_array[2310] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.interfaces = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2311] == 0) {
    {
    fprintf(_coverage_fout, "2311\n");
    fflush(_coverage_fout);
    ___coverage_array[2311] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.get_iterator = (zend_object_iterator *(*)(zend_class_entry *ce ,
                                                    zval *object , int by_ref ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2312] == 0) {
    {
    fprintf(_coverage_fout, "2312\n");
    fflush(_coverage_fout);
    ___coverage_array[2312] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.iterator_funcs.funcs = (zend_object_iterator_funcs *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2313] == 0) {
    {
    fprintf(_coverage_fout, "2313\n");
    fflush(_coverage_fout);
    ___coverage_array[2313] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.info.internal.module = (struct _zend_module_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2314] == 0) {
    {
    fprintf(_coverage_fout, "2314\n");
    fflush(_coverage_fout);
    ___coverage_array[2314] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.info.internal.builtin_functions = date_funcs_date;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2315] == 0) {
    {
    fprintf(_coverage_fout, "2315\n");
    fflush(_coverage_fout);
    ___coverage_array[2315] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_date.create_object = & date_object_new_date;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2316] == 0) {
    {
    fprintf(_coverage_fout, "2316\n");
    fflush(_coverage_fout);
    ___coverage_array[2316] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_register_internal_class_ex(& ce_date,
                                            (zend_class_entry *)((void *)0),
                                            (char *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2317] == 0) {
    {
    fprintf(_coverage_fout, "2317\n");
    fflush(_coverage_fout);
    ___coverage_array[2317] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_ce_date = (zend_class_entry *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2318] == 0) {
    {
    fprintf(_coverage_fout, "2318\n");
    fflush(_coverage_fout);
    ___coverage_array[2318] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zend_get_std_object_handlers();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2319] == 0) {
    {
    fprintf(_coverage_fout, "2319\n");
    fflush(_coverage_fout);
    ___coverage_array[2319] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memcpy((void */* __restrict  */)(& date_object_handlers_date),
         (void const   */* __restrict  */)tmp___2, sizeof(zend_object_handlers ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2320] == 0) {
    {
    fprintf(_coverage_fout, "2320\n");
    fflush(_coverage_fout);
    ___coverage_array[2320] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_date.clone_obj = & date_object_clone_date;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2321] == 0) {
    {
    fprintf(_coverage_fout, "2321\n");
    fflush(_coverage_fout);
    ___coverage_array[2321] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_date.compare_objects = & date_object_compare_date;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2322] == 0) {
    {
    fprintf(_coverage_fout, "2322\n");
    fflush(_coverage_fout);
    ___coverage_array[2322] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_date.get_properties = & date_object_get_properties;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2323] == 0) {
    {
    fprintf(_coverage_fout, "2323\n");
    fflush(_coverage_fout);
    ___coverage_array[2323] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "ATOM", sizeof("ATOM") - 1U,
                                      "Y-m-d\\TH:i:sP",
                                      sizeof("Y-m-d\\TH:i:sP") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2324] == 0) {
    {
    fprintf(_coverage_fout, "2324\n");
    fflush(_coverage_fout);
    ___coverage_array[2324] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "COOKIE",
                                      sizeof("COOKIE") - 1U, "l, d-M-y H:i:s T",
                                      sizeof("l, d-M-y H:i:s T") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2325] == 0) {
    {
    fprintf(_coverage_fout, "2325\n");
    fflush(_coverage_fout);
    ___coverage_array[2325] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "ISO8601",
                                      sizeof("ISO8601") - 1U, "Y-m-d\\TH:i:sO",
                                      sizeof("Y-m-d\\TH:i:sO") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2326] == 0) {
    {
    fprintf(_coverage_fout, "2326\n");
    fflush(_coverage_fout);
    ___coverage_array[2326] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RFC822",
                                      sizeof("RFC822") - 1U, "D, d M y H:i:s O",
                                      sizeof("D, d M y H:i:s O") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2327] == 0) {
    {
    fprintf(_coverage_fout, "2327\n");
    fflush(_coverage_fout);
    ___coverage_array[2327] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RFC850",
                                      sizeof("RFC850") - 1U, "l, d-M-y H:i:s T",
                                      sizeof("l, d-M-y H:i:s T") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2328] == 0) {
    {
    fprintf(_coverage_fout, "2328\n");
    fflush(_coverage_fout);
    ___coverage_array[2328] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RFC1036",
                                      sizeof("RFC1036") - 1U,
                                      "D, d M y H:i:s O",
                                      sizeof("D, d M y H:i:s O") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2329] == 0) {
    {
    fprintf(_coverage_fout, "2329\n");
    fflush(_coverage_fout);
    ___coverage_array[2329] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RFC1123",
                                      sizeof("RFC1123") - 1U,
                                      "D, d M Y H:i:s O",
                                      sizeof("D, d M Y H:i:s O") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2330] == 0) {
    {
    fprintf(_coverage_fout, "2330\n");
    fflush(_coverage_fout);
    ___coverage_array[2330] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RFC2822",
                                      sizeof("RFC2822") - 1U,
                                      "D, d M Y H:i:s O",
                                      sizeof("D, d M Y H:i:s O") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2331] == 0) {
    {
    fprintf(_coverage_fout, "2331\n");
    fflush(_coverage_fout);
    ___coverage_array[2331] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RFC3339",
                                      sizeof("RFC3339") - 1U, "Y-m-d\\TH:i:sP",
                                      sizeof("Y-m-d\\TH:i:sP") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2332] == 0) {
    {
    fprintf(_coverage_fout, "2332\n");
    fflush(_coverage_fout);
    ___coverage_array[2332] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "RSS", sizeof("RSS") - 1U,
                                      "D, d M Y H:i:s O",
                                      sizeof("D, d M Y H:i:s O") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2333] == 0) {
    {
    fprintf(_coverage_fout, "2333\n");
    fflush(_coverage_fout);
    ___coverage_array[2333] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_stringl(date_ce_date, "W3C", sizeof("W3C") - 1U,
                                      "Y-m-d\\TH:i:sP",
                                      sizeof("Y-m-d\\TH:i:sP") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2334] == 0) {
    {
    fprintf(_coverage_fout, "2334\n");
    fflush(_coverage_fout);
    ___coverage_array[2334] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  cl_name___0 = "DateTimeZone";
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2335] == 0) {
    {
    fprintf(_coverage_fout, "2335\n");
    fflush(_coverage_fout);
    ___coverage_array[2335] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _len___0 = (int )(sizeof("DateTimeZone") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2336] == 0) {
    {
    fprintf(_coverage_fout, "2336\n");
    fflush(_coverage_fout);
    ___coverage_array[2336] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = (*zend_new_interned_string)(cl_name___0, _len___0 + 1, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2337] == 0) {
    {
    fprintf(_coverage_fout, "2337\n");
    fflush(_coverage_fout);
    ___coverage_array[2337] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.name = (char const   *)tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2338] == 0) {
    {
    fprintf(_coverage_fout, "2338\n");
    fflush(_coverage_fout);
    ___coverage_array[2338] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )ce_timezone.name == (unsigned int )cl_name___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2270] == 0) {
      {
      fprintf(_coverage_fout, "2270\n");
      fflush(_coverage_fout);
      ___coverage_array[2270] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = zend_strndup(cl_name___0, (unsigned int )_len___0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2271] == 0) {
      {
      fprintf(_coverage_fout, "2271\n");
      fflush(_coverage_fout);
      ___coverage_array[2271] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce_timezone.name = (char const   *)tmp___4;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2272] == 0) {
      {
      fprintf(_coverage_fout, "2272\n");
      fflush(_coverage_fout);
      ___coverage_array[2272] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2339] == 0) {
    {
    fprintf(_coverage_fout, "2339\n");
    fflush(_coverage_fout);
    ___coverage_array[2339] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.name_length = (unsigned int )_len___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2340] == 0) {
    {
    fprintf(_coverage_fout, "2340\n");
    fflush(_coverage_fout);
    ___coverage_array[2340] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.constructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2341] == 0) {
    {
    fprintf(_coverage_fout, "2341\n");
    fflush(_coverage_fout);
    ___coverage_array[2341] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.destructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2342] == 0) {
    {
    fprintf(_coverage_fout, "2342\n");
    fflush(_coverage_fout);
    ___coverage_array[2342] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.clone = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2343] == 0) {
    {
    fprintf(_coverage_fout, "2343\n");
    fflush(_coverage_fout);
    ___coverage_array[2343] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.serialize = (int (*)(zval *object , unsigned char **buffer ,
                                   zend_uint *buf_len ,
                                   zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2344] == 0) {
    {
    fprintf(_coverage_fout, "2344\n");
    fflush(_coverage_fout);
    ___coverage_array[2344] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                     unsigned char const   *buf ,
                                     zend_uint buf_len ,
                                     zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2345] == 0) {
    {
    fprintf(_coverage_fout, "2345\n");
    fflush(_coverage_fout);
    ___coverage_array[2345] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.create_object = (zend_object_value (*)(zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2346] == 0) {
    {
    fprintf(_coverage_fout, "2346\n");
    fflush(_coverage_fout);
    ___coverage_array[2346] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.interface_gets_implemented = (int (*)(zend_class_entry *iface ,
                                                    zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2347] == 0) {
    {
    fprintf(_coverage_fout, "2347\n");
    fflush(_coverage_fout);
    ___coverage_array[2347] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.get_static_method = (union _zend_function *(*)(zend_class_entry *ce ,
                                                             char *method ,
                                                             int method_len ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2348] == 0) {
    {
    fprintf(_coverage_fout, "2348\n");
    fflush(_coverage_fout);
    ___coverage_array[2348] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__call = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2349] == 0) {
    {
    fprintf(_coverage_fout, "2349\n");
    fflush(_coverage_fout);
    ___coverage_array[2349] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__callstatic = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2350] == 0) {
    {
    fprintf(_coverage_fout, "2350\n");
    fflush(_coverage_fout);
    ___coverage_array[2350] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__tostring = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2351] == 0) {
    {
    fprintf(_coverage_fout, "2351\n");
    fflush(_coverage_fout);
    ___coverage_array[2351] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__get = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2352] == 0) {
    {
    fprintf(_coverage_fout, "2352\n");
    fflush(_coverage_fout);
    ___coverage_array[2352] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__set = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2353] == 0) {
    {
    fprintf(_coverage_fout, "2353\n");
    fflush(_coverage_fout);
    ___coverage_array[2353] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__unset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2354] == 0) {
    {
    fprintf(_coverage_fout, "2354\n");
    fflush(_coverage_fout);
    ___coverage_array[2354] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.__isset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2355] == 0) {
    {
    fprintf(_coverage_fout, "2355\n");
    fflush(_coverage_fout);
    ___coverage_array[2355] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.serialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2356] == 0) {
    {
    fprintf(_coverage_fout, "2356\n");
    fflush(_coverage_fout);
    ___coverage_array[2356] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.unserialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2357] == 0) {
    {
    fprintf(_coverage_fout, "2357\n");
    fflush(_coverage_fout);
    ___coverage_array[2357] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.serialize = (int (*)(zval *object , unsigned char **buffer ,
                                   zend_uint *buf_len ,
                                   zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2358] == 0) {
    {
    fprintf(_coverage_fout, "2358\n");
    fflush(_coverage_fout);
    ___coverage_array[2358] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                     unsigned char const   *buf ,
                                     zend_uint buf_len ,
                                     zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2359] == 0) {
    {
    fprintf(_coverage_fout, "2359\n");
    fflush(_coverage_fout);
    ___coverage_array[2359] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.parent = (struct _zend_class_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2360] == 0) {
    {
    fprintf(_coverage_fout, "2360\n");
    fflush(_coverage_fout);
    ___coverage_array[2360] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.num_interfaces = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2361] == 0) {
    {
    fprintf(_coverage_fout, "2361\n");
    fflush(_coverage_fout);
    ___coverage_array[2361] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.traits = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2362] == 0) {
    {
    fprintf(_coverage_fout, "2362\n");
    fflush(_coverage_fout);
    ___coverage_array[2362] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.num_traits = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2363] == 0) {
    {
    fprintf(_coverage_fout, "2363\n");
    fflush(_coverage_fout);
    ___coverage_array[2363] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.trait_aliases = (zend_trait_alias **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2364] == 0) {
    {
    fprintf(_coverage_fout, "2364\n");
    fflush(_coverage_fout);
    ___coverage_array[2364] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.trait_precedences = (zend_trait_precedence **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2365] == 0) {
    {
    fprintf(_coverage_fout, "2365\n");
    fflush(_coverage_fout);
    ___coverage_array[2365] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.interfaces = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2366] == 0) {
    {
    fprintf(_coverage_fout, "2366\n");
    fflush(_coverage_fout);
    ___coverage_array[2366] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.get_iterator = (zend_object_iterator *(*)(zend_class_entry *ce ,
                                                        zval *object ,
                                                        int by_ref ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2367] == 0) {
    {
    fprintf(_coverage_fout, "2367\n");
    fflush(_coverage_fout);
    ___coverage_array[2367] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.iterator_funcs.funcs = (zend_object_iterator_funcs *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2368] == 0) {
    {
    fprintf(_coverage_fout, "2368\n");
    fflush(_coverage_fout);
    ___coverage_array[2368] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.info.internal.module = (struct _zend_module_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2369] == 0) {
    {
    fprintf(_coverage_fout, "2369\n");
    fflush(_coverage_fout);
    ___coverage_array[2369] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.info.internal.builtin_functions = date_funcs_timezone;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2370] == 0) {
    {
    fprintf(_coverage_fout, "2370\n");
    fflush(_coverage_fout);
    ___coverage_array[2370] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_timezone.create_object = & date_object_new_timezone;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2371] == 0) {
    {
    fprintf(_coverage_fout, "2371\n");
    fflush(_coverage_fout);
    ___coverage_array[2371] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = zend_register_internal_class_ex(& ce_timezone,
                                            (zend_class_entry *)((void *)0),
                                            (char *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2372] == 0) {
    {
    fprintf(_coverage_fout, "2372\n");
    fflush(_coverage_fout);
    ___coverage_array[2372] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_ce_timezone = (zend_class_entry *)tmp___5;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2373] == 0) {
    {
    fprintf(_coverage_fout, "2373\n");
    fflush(_coverage_fout);
    ___coverage_array[2373] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___6 = zend_get_std_object_handlers();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2374] == 0) {
    {
    fprintf(_coverage_fout, "2374\n");
    fflush(_coverage_fout);
    ___coverage_array[2374] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memcpy((void */* __restrict  */)(& date_object_handlers_timezone),
         (void const   */* __restrict  */)tmp___6, sizeof(zend_object_handlers ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2375] == 0) {
    {
    fprintf(_coverage_fout, "2375\n");
    fflush(_coverage_fout);
    ___coverage_array[2375] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_timezone.clone_obj = & date_object_clone_timezone;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2376] == 0) {
    {
    fprintf(_coverage_fout, "2376\n");
    fflush(_coverage_fout);
    ___coverage_array[2376] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "AFRICA",
                                   sizeof("AFRICA") - 1U, 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2377] == 0) {
    {
    fprintf(_coverage_fout, "2377\n");
    fflush(_coverage_fout);
    ___coverage_array[2377] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "AMERICA",
                                   sizeof("AMERICA") - 1U, 2L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2378] == 0) {
    {
    fprintf(_coverage_fout, "2378\n");
    fflush(_coverage_fout);
    ___coverage_array[2378] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "ANTARCTICA",
                                   sizeof("ANTARCTICA") - 1U, 4L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2379] == 0) {
    {
    fprintf(_coverage_fout, "2379\n");
    fflush(_coverage_fout);
    ___coverage_array[2379] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "ARCTIC",
                                   sizeof("ARCTIC") - 1U, 8L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2380] == 0) {
    {
    fprintf(_coverage_fout, "2380\n");
    fflush(_coverage_fout);
    ___coverage_array[2380] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "ASIA",
                                   sizeof("ASIA") - 1U, 16L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2381] == 0) {
    {
    fprintf(_coverage_fout, "2381\n");
    fflush(_coverage_fout);
    ___coverage_array[2381] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "ATLANTIC",
                                   sizeof("ATLANTIC") - 1U, 32L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2382] == 0) {
    {
    fprintf(_coverage_fout, "2382\n");
    fflush(_coverage_fout);
    ___coverage_array[2382] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "AUSTRALIA",
                                   sizeof("AUSTRALIA") - 1U, 64L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2383] == 0) {
    {
    fprintf(_coverage_fout, "2383\n");
    fflush(_coverage_fout);
    ___coverage_array[2383] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "EUROPE",
                                   sizeof("EUROPE") - 1U, 128L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2384] == 0) {
    {
    fprintf(_coverage_fout, "2384\n");
    fflush(_coverage_fout);
    ___coverage_array[2384] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "INDIAN",
                                   sizeof("INDIAN") - 1U, 256L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2385] == 0) {
    {
    fprintf(_coverage_fout, "2385\n");
    fflush(_coverage_fout);
    ___coverage_array[2385] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "PACIFIC",
                                   sizeof("PACIFIC") - 1U, 512L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2386] == 0) {
    {
    fprintf(_coverage_fout, "2386\n");
    fflush(_coverage_fout);
    ___coverage_array[2386] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "UTC", sizeof("UTC") - 1U,
                                   1024L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2387] == 0) {
    {
    fprintf(_coverage_fout, "2387\n");
    fflush(_coverage_fout);
    ___coverage_array[2387] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "ALL", sizeof("ALL") - 1U,
                                   2047L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2388] == 0) {
    {
    fprintf(_coverage_fout, "2388\n");
    fflush(_coverage_fout);
    ___coverage_array[2388] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "ALL_WITH_BC",
                                   sizeof("ALL_WITH_BC") - 1U, 4095L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2389] == 0) {
    {
    fprintf(_coverage_fout, "2389\n");
    fflush(_coverage_fout);
    ___coverage_array[2389] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_timezone, "PER_COUNTRY",
                                   sizeof("PER_COUNTRY") - 1U, 4096L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2390] == 0) {
    {
    fprintf(_coverage_fout, "2390\n");
    fflush(_coverage_fout);
    ___coverage_array[2390] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  cl_name___1 = "DateInterval";
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2391] == 0) {
    {
    fprintf(_coverage_fout, "2391\n");
    fflush(_coverage_fout);
    ___coverage_array[2391] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _len___1 = (int )(sizeof("DateInterval") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2392] == 0) {
    {
    fprintf(_coverage_fout, "2392\n");
    fflush(_coverage_fout);
    ___coverage_array[2392] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___7 = (*zend_new_interned_string)(cl_name___1, _len___1 + 1, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2393] == 0) {
    {
    fprintf(_coverage_fout, "2393\n");
    fflush(_coverage_fout);
    ___coverage_array[2393] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.name = (char const   *)tmp___7;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2394] == 0) {
    {
    fprintf(_coverage_fout, "2394\n");
    fflush(_coverage_fout);
    ___coverage_array[2394] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )ce_interval.name == (unsigned int )cl_name___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2273] == 0) {
      {
      fprintf(_coverage_fout, "2273\n");
      fflush(_coverage_fout);
      ___coverage_array[2273] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___8 = zend_strndup(cl_name___1, (unsigned int )_len___1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2274] == 0) {
      {
      fprintf(_coverage_fout, "2274\n");
      fflush(_coverage_fout);
      ___coverage_array[2274] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce_interval.name = (char const   *)tmp___8;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2275] == 0) {
      {
      fprintf(_coverage_fout, "2275\n");
      fflush(_coverage_fout);
      ___coverage_array[2275] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2395] == 0) {
    {
    fprintf(_coverage_fout, "2395\n");
    fflush(_coverage_fout);
    ___coverage_array[2395] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.name_length = (unsigned int )_len___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2396] == 0) {
    {
    fprintf(_coverage_fout, "2396\n");
    fflush(_coverage_fout);
    ___coverage_array[2396] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.constructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2397] == 0) {
    {
    fprintf(_coverage_fout, "2397\n");
    fflush(_coverage_fout);
    ___coverage_array[2397] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.destructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2398] == 0) {
    {
    fprintf(_coverage_fout, "2398\n");
    fflush(_coverage_fout);
    ___coverage_array[2398] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.clone = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2399] == 0) {
    {
    fprintf(_coverage_fout, "2399\n");
    fflush(_coverage_fout);
    ___coverage_array[2399] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.serialize = (int (*)(zval *object , unsigned char **buffer ,
                                   zend_uint *buf_len ,
                                   zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2400] == 0) {
    {
    fprintf(_coverage_fout, "2400\n");
    fflush(_coverage_fout);
    ___coverage_array[2400] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                     unsigned char const   *buf ,
                                     zend_uint buf_len ,
                                     zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2401] == 0) {
    {
    fprintf(_coverage_fout, "2401\n");
    fflush(_coverage_fout);
    ___coverage_array[2401] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.create_object = (zend_object_value (*)(zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2402] == 0) {
    {
    fprintf(_coverage_fout, "2402\n");
    fflush(_coverage_fout);
    ___coverage_array[2402] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.interface_gets_implemented = (int (*)(zend_class_entry *iface ,
                                                    zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2403] == 0) {
    {
    fprintf(_coverage_fout, "2403\n");
    fflush(_coverage_fout);
    ___coverage_array[2403] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.get_static_method = (union _zend_function *(*)(zend_class_entry *ce ,
                                                             char *method ,
                                                             int method_len ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2404] == 0) {
    {
    fprintf(_coverage_fout, "2404\n");
    fflush(_coverage_fout);
    ___coverage_array[2404] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__call = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2405] == 0) {
    {
    fprintf(_coverage_fout, "2405\n");
    fflush(_coverage_fout);
    ___coverage_array[2405] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__callstatic = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2406] == 0) {
    {
    fprintf(_coverage_fout, "2406\n");
    fflush(_coverage_fout);
    ___coverage_array[2406] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__tostring = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2407] == 0) {
    {
    fprintf(_coverage_fout, "2407\n");
    fflush(_coverage_fout);
    ___coverage_array[2407] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__get = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2408] == 0) {
    {
    fprintf(_coverage_fout, "2408\n");
    fflush(_coverage_fout);
    ___coverage_array[2408] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__set = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2409] == 0) {
    {
    fprintf(_coverage_fout, "2409\n");
    fflush(_coverage_fout);
    ___coverage_array[2409] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__unset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2410] == 0) {
    {
    fprintf(_coverage_fout, "2410\n");
    fflush(_coverage_fout);
    ___coverage_array[2410] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.__isset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2411] == 0) {
    {
    fprintf(_coverage_fout, "2411\n");
    fflush(_coverage_fout);
    ___coverage_array[2411] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.serialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2412] == 0) {
    {
    fprintf(_coverage_fout, "2412\n");
    fflush(_coverage_fout);
    ___coverage_array[2412] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.unserialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2413] == 0) {
    {
    fprintf(_coverage_fout, "2413\n");
    fflush(_coverage_fout);
    ___coverage_array[2413] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.serialize = (int (*)(zval *object , unsigned char **buffer ,
                                   zend_uint *buf_len ,
                                   zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2414] == 0) {
    {
    fprintf(_coverage_fout, "2414\n");
    fflush(_coverage_fout);
    ___coverage_array[2414] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                     unsigned char const   *buf ,
                                     zend_uint buf_len ,
                                     zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2415] == 0) {
    {
    fprintf(_coverage_fout, "2415\n");
    fflush(_coverage_fout);
    ___coverage_array[2415] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.parent = (struct _zend_class_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2416] == 0) {
    {
    fprintf(_coverage_fout, "2416\n");
    fflush(_coverage_fout);
    ___coverage_array[2416] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.num_interfaces = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2417] == 0) {
    {
    fprintf(_coverage_fout, "2417\n");
    fflush(_coverage_fout);
    ___coverage_array[2417] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.traits = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2418] == 0) {
    {
    fprintf(_coverage_fout, "2418\n");
    fflush(_coverage_fout);
    ___coverage_array[2418] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.num_traits = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2419] == 0) {
    {
    fprintf(_coverage_fout, "2419\n");
    fflush(_coverage_fout);
    ___coverage_array[2419] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.trait_aliases = (zend_trait_alias **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2420] == 0) {
    {
    fprintf(_coverage_fout, "2420\n");
    fflush(_coverage_fout);
    ___coverage_array[2420] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.trait_precedences = (zend_trait_precedence **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2421] == 0) {
    {
    fprintf(_coverage_fout, "2421\n");
    fflush(_coverage_fout);
    ___coverage_array[2421] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.interfaces = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2422] == 0) {
    {
    fprintf(_coverage_fout, "2422\n");
    fflush(_coverage_fout);
    ___coverage_array[2422] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.get_iterator = (zend_object_iterator *(*)(zend_class_entry *ce ,
                                                        zval *object ,
                                                        int by_ref ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2423] == 0) {
    {
    fprintf(_coverage_fout, "2423\n");
    fflush(_coverage_fout);
    ___coverage_array[2423] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.iterator_funcs.funcs = (zend_object_iterator_funcs *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2424] == 0) {
    {
    fprintf(_coverage_fout, "2424\n");
    fflush(_coverage_fout);
    ___coverage_array[2424] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.info.internal.module = (struct _zend_module_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2425] == 0) {
    {
    fprintf(_coverage_fout, "2425\n");
    fflush(_coverage_fout);
    ___coverage_array[2425] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.info.internal.builtin_functions = date_funcs_interval;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2426] == 0) {
    {
    fprintf(_coverage_fout, "2426\n");
    fflush(_coverage_fout);
    ___coverage_array[2426] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_interval.create_object = & date_object_new_interval;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2427] == 0) {
    {
    fprintf(_coverage_fout, "2427\n");
    fflush(_coverage_fout);
    ___coverage_array[2427] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___9 = zend_register_internal_class_ex(& ce_interval,
                                            (zend_class_entry *)((void *)0),
                                            (char *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2428] == 0) {
    {
    fprintf(_coverage_fout, "2428\n");
    fflush(_coverage_fout);
    ___coverage_array[2428] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_ce_interval = (zend_class_entry *)tmp___9;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2429] == 0) {
    {
    fprintf(_coverage_fout, "2429\n");
    fflush(_coverage_fout);
    ___coverage_array[2429] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___10 = zend_get_std_object_handlers();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2430] == 0) {
    {
    fprintf(_coverage_fout, "2430\n");
    fflush(_coverage_fout);
    ___coverage_array[2430] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memcpy((void */* __restrict  */)(& date_object_handlers_interval),
         (void const   */* __restrict  */)tmp___10,
         sizeof(zend_object_handlers ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2431] == 0) {
    {
    fprintf(_coverage_fout, "2431\n");
    fflush(_coverage_fout);
    ___coverage_array[2431] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_interval.clone_obj = & date_object_clone_interval;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2432] == 0) {
    {
    fprintf(_coverage_fout, "2432\n");
    fflush(_coverage_fout);
    ___coverage_array[2432] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_interval.read_property = & date_interval_read_property;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2433] == 0) {
    {
    fprintf(_coverage_fout, "2433\n");
    fflush(_coverage_fout);
    ___coverage_array[2433] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_interval.write_property = & date_interval_write_property;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2434] == 0) {
    {
    fprintf(_coverage_fout, "2434\n");
    fflush(_coverage_fout);
    ___coverage_array[2434] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_interval.get_properties = & date_object_get_properties_interval;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2435] == 0) {
    {
    fprintf(_coverage_fout, "2435\n");
    fflush(_coverage_fout);
    ___coverage_array[2435] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_interval.get_property_ptr_ptr = (zval **(*)(zval *object ,
                                                                   zval *member ,
                                                                   struct _zend_literal  const  *key ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2436] == 0) {
    {
    fprintf(_coverage_fout, "2436\n");
    fflush(_coverage_fout);
    ___coverage_array[2436] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  cl_name___2 = "DatePeriod";
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2437] == 0) {
    {
    fprintf(_coverage_fout, "2437\n");
    fflush(_coverage_fout);
    ___coverage_array[2437] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _len___2 = (int )(sizeof("DatePeriod") - 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2438] == 0) {
    {
    fprintf(_coverage_fout, "2438\n");
    fflush(_coverage_fout);
    ___coverage_array[2438] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___11 = (*zend_new_interned_string)(cl_name___2, _len___2 + 1, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2439] == 0) {
    {
    fprintf(_coverage_fout, "2439\n");
    fflush(_coverage_fout);
    ___coverage_array[2439] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.name = (char const   *)tmp___11;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2440] == 0) {
    {
    fprintf(_coverage_fout, "2440\n");
    fflush(_coverage_fout);
    ___coverage_array[2440] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )ce_period.name == (unsigned int )cl_name___2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2276] == 0) {
      {
      fprintf(_coverage_fout, "2276\n");
      fflush(_coverage_fout);
      ___coverage_array[2276] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___12 = zend_strndup(cl_name___2, (unsigned int )_len___2);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2277] == 0) {
      {
      fprintf(_coverage_fout, "2277\n");
      fflush(_coverage_fout);
      ___coverage_array[2277] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ce_period.name = (char const   *)tmp___12;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2278] == 0) {
      {
      fprintf(_coverage_fout, "2278\n");
      fflush(_coverage_fout);
      ___coverage_array[2278] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2441] == 0) {
    {
    fprintf(_coverage_fout, "2441\n");
    fflush(_coverage_fout);
    ___coverage_array[2441] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.name_length = (unsigned int )_len___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2442] == 0) {
    {
    fprintf(_coverage_fout, "2442\n");
    fflush(_coverage_fout);
    ___coverage_array[2442] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.constructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2443] == 0) {
    {
    fprintf(_coverage_fout, "2443\n");
    fflush(_coverage_fout);
    ___coverage_array[2443] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.destructor = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2444] == 0) {
    {
    fprintf(_coverage_fout, "2444\n");
    fflush(_coverage_fout);
    ___coverage_array[2444] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.clone = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2445] == 0) {
    {
    fprintf(_coverage_fout, "2445\n");
    fflush(_coverage_fout);
    ___coverage_array[2445] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.serialize = (int (*)(zval *object , unsigned char **buffer ,
                                 zend_uint *buf_len , zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2446] == 0) {
    {
    fprintf(_coverage_fout, "2446\n");
    fflush(_coverage_fout);
    ___coverage_array[2446] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                   unsigned char const   *buf ,
                                   zend_uint buf_len ,
                                   zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2447] == 0) {
    {
    fprintf(_coverage_fout, "2447\n");
    fflush(_coverage_fout);
    ___coverage_array[2447] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.create_object = (zend_object_value (*)(zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2448] == 0) {
    {
    fprintf(_coverage_fout, "2448\n");
    fflush(_coverage_fout);
    ___coverage_array[2448] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.interface_gets_implemented = (int (*)(zend_class_entry *iface ,
                                                  zend_class_entry *class_type ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2449] == 0) {
    {
    fprintf(_coverage_fout, "2449\n");
    fflush(_coverage_fout);
    ___coverage_array[2449] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.get_static_method = (union _zend_function *(*)(zend_class_entry *ce ,
                                                           char *method ,
                                                           int method_len ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2450] == 0) {
    {
    fprintf(_coverage_fout, "2450\n");
    fflush(_coverage_fout);
    ___coverage_array[2450] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__call = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2451] == 0) {
    {
    fprintf(_coverage_fout, "2451\n");
    fflush(_coverage_fout);
    ___coverage_array[2451] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__callstatic = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2452] == 0) {
    {
    fprintf(_coverage_fout, "2452\n");
    fflush(_coverage_fout);
    ___coverage_array[2452] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__tostring = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2453] == 0) {
    {
    fprintf(_coverage_fout, "2453\n");
    fflush(_coverage_fout);
    ___coverage_array[2453] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__get = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2454] == 0) {
    {
    fprintf(_coverage_fout, "2454\n");
    fflush(_coverage_fout);
    ___coverage_array[2454] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__set = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2455] == 0) {
    {
    fprintf(_coverage_fout, "2455\n");
    fflush(_coverage_fout);
    ___coverage_array[2455] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__unset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2456] == 0) {
    {
    fprintf(_coverage_fout, "2456\n");
    fflush(_coverage_fout);
    ___coverage_array[2456] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.__isset = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2457] == 0) {
    {
    fprintf(_coverage_fout, "2457\n");
    fflush(_coverage_fout);
    ___coverage_array[2457] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.serialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2458] == 0) {
    {
    fprintf(_coverage_fout, "2458\n");
    fflush(_coverage_fout);
    ___coverage_array[2458] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.unserialize_func = (union _zend_function *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2459] == 0) {
    {
    fprintf(_coverage_fout, "2459\n");
    fflush(_coverage_fout);
    ___coverage_array[2459] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.serialize = (int (*)(zval *object , unsigned char **buffer ,
                                 zend_uint *buf_len , zend_serialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2460] == 0) {
    {
    fprintf(_coverage_fout, "2460\n");
    fflush(_coverage_fout);
    ___coverage_array[2460] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.unserialize = (int (*)(zval **object , zend_class_entry *ce ,
                                   unsigned char const   *buf ,
                                   zend_uint buf_len ,
                                   zend_unserialize_data *data ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2461] == 0) {
    {
    fprintf(_coverage_fout, "2461\n");
    fflush(_coverage_fout);
    ___coverage_array[2461] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.parent = (struct _zend_class_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2462] == 0) {
    {
    fprintf(_coverage_fout, "2462\n");
    fflush(_coverage_fout);
    ___coverage_array[2462] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.num_interfaces = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2463] == 0) {
    {
    fprintf(_coverage_fout, "2463\n");
    fflush(_coverage_fout);
    ___coverage_array[2463] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.traits = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2464] == 0) {
    {
    fprintf(_coverage_fout, "2464\n");
    fflush(_coverage_fout);
    ___coverage_array[2464] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.num_traits = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2465] == 0) {
    {
    fprintf(_coverage_fout, "2465\n");
    fflush(_coverage_fout);
    ___coverage_array[2465] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.trait_aliases = (zend_trait_alias **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2466] == 0) {
    {
    fprintf(_coverage_fout, "2466\n");
    fflush(_coverage_fout);
    ___coverage_array[2466] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.trait_precedences = (zend_trait_precedence **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2467] == 0) {
    {
    fprintf(_coverage_fout, "2467\n");
    fflush(_coverage_fout);
    ___coverage_array[2467] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.interfaces = (zend_class_entry **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2468] == 0) {
    {
    fprintf(_coverage_fout, "2468\n");
    fflush(_coverage_fout);
    ___coverage_array[2468] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.get_iterator = (zend_object_iterator *(*)(zend_class_entry *ce ,
                                                      zval *object , int by_ref ))((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2469] == 0) {
    {
    fprintf(_coverage_fout, "2469\n");
    fflush(_coverage_fout);
    ___coverage_array[2469] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.iterator_funcs.funcs = (zend_object_iterator_funcs *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2470] == 0) {
    {
    fprintf(_coverage_fout, "2470\n");
    fflush(_coverage_fout);
    ___coverage_array[2470] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.info.internal.module = (struct _zend_module_entry *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2471] == 0) {
    {
    fprintf(_coverage_fout, "2471\n");
    fflush(_coverage_fout);
    ___coverage_array[2471] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.info.internal.builtin_functions = date_funcs_period;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2472] == 0) {
    {
    fprintf(_coverage_fout, "2472\n");
    fflush(_coverage_fout);
    ___coverage_array[2472] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ce_period.create_object = & date_object_new_period;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2473] == 0) {
    {
    fprintf(_coverage_fout, "2473\n");
    fflush(_coverage_fout);
    ___coverage_array[2473] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___13 = zend_register_internal_class_ex(& ce_period,
                                             (zend_class_entry *)((void *)0),
                                             (char *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2474] == 0) {
    {
    fprintf(_coverage_fout, "2474\n");
    fflush(_coverage_fout);
    ___coverage_array[2474] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_ce_period = (zend_class_entry *)tmp___13;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2475] == 0) {
    {
    fprintf(_coverage_fout, "2475\n");
    fflush(_coverage_fout);
    ___coverage_array[2475] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_ce_period->get_iterator = & date_object_period_get_iterator;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2476] == 0) {
    {
    fprintf(_coverage_fout, "2476\n");
    fflush(_coverage_fout);
    ___coverage_array[2476] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_ce_period->iterator_funcs.funcs = & date_period_it_funcs;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2477] == 0) {
    {
    fprintf(_coverage_fout, "2477\n");
    fflush(_coverage_fout);
    ___coverage_array[2477] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_class_implements(date_ce_period, 1, zend_ce_traversable);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2478] == 0) {
    {
    fprintf(_coverage_fout, "2478\n");
    fflush(_coverage_fout);
    ___coverage_array[2478] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___14 = zend_get_std_object_handlers();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2479] == 0) {
    {
    fprintf(_coverage_fout, "2479\n");
    fflush(_coverage_fout);
    ___coverage_array[2479] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memcpy((void */* __restrict  */)(& date_object_handlers_period),
         (void const   */* __restrict  */)tmp___14,
         sizeof(zend_object_handlers ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2480] == 0) {
    {
    fprintf(_coverage_fout, "2480\n");
    fflush(_coverage_fout);
    ___coverage_array[2480] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_object_handlers_period.clone_obj = & date_object_clone_period;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2481] == 0) {
    {
    fprintf(_coverage_fout, "2481\n");
    fflush(_coverage_fout);
    ___coverage_array[2481] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_declare_class_constant_long(date_ce_period, "EXCLUDE_START_DATE",
                                   sizeof("EXCLUDE_START_DATE") - 1U, 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2482] == 0) {
    {
    fprintf(_coverage_fout, "2482\n");
    fflush(_coverage_fout);
    ___coverage_array[2482] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
__inline static zend_object_value date_object_new_date_ex(zend_class_entry *class_type ,
                                                          php_date_obj **ptr ) 
{ php_date_obj *intern ;
  zend_object_value retval ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_handle __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2485] == 0) {
    {
    fprintf(_coverage_fout, "2485\n");
    fflush(_coverage_fout);
    ___coverage_array[2485] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(php_date_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2486] == 0) {
    {
    fprintf(_coverage_fout, "2486\n");
    fflush(_coverage_fout);
    ___coverage_array[2486] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_date_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2487] == 0) {
    {
    fprintf(_coverage_fout, "2487\n");
    fflush(_coverage_fout);
    ___coverage_array[2487] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset((void *)intern, 0, sizeof(php_date_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2488] == 0) {
    {
    fprintf(_coverage_fout, "2488\n");
    fflush(_coverage_fout);
    ___coverage_array[2488] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2483] == 0) {
      {
      fprintf(_coverage_fout, "2483\n");
      fflush(_coverage_fout);
      ___coverage_array[2483] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *ptr = intern;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2484] == 0) {
      {
      fprintf(_coverage_fout, "2484\n");
      fflush(_coverage_fout);
      ___coverage_array[2484] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2489] == 0) {
    {
    fprintf(_coverage_fout, "2489\n");
    fflush(_coverage_fout);
    ___coverage_array[2489] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2490] == 0) {
    {
    fprintf(_coverage_fout, "2490\n");
    fflush(_coverage_fout);
    ___coverage_array[2490] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object_properties_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2491] == 0) {
    {
    fprintf(_coverage_fout, "2491\n");
    fflush(_coverage_fout);
    ___coverage_array[2491] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_objects_store_put((void *)intern,
                                   (void (*)(void *object ,
                                             zend_object_handle handle ))(& zend_objects_destroy_object),
                                   & date_object_free_storage_date,
                                   (void (*)(void *object , void **object_clone ))((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2492] == 0) {
    {
    fprintf(_coverage_fout, "2492\n");
    fflush(_coverage_fout);
    ___coverage_array[2492] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handle = (unsigned int )tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2493] == 0) {
    {
    fprintf(_coverage_fout, "2493\n");
    fflush(_coverage_fout);
    ___coverage_array[2493] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handlers = & date_object_handlers_date;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2494] == 0) {
    {
    fprintf(_coverage_fout, "2494\n");
    fflush(_coverage_fout);
    ___coverage_array[2494] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
static zend_object_value date_object_new_date(zend_class_entry *class_type ) 
{ zend_object_value tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2495] == 0) {
    {
    fprintf(_coverage_fout, "2495\n");
    fflush(_coverage_fout);
    ___coverage_array[2495] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = date_object_new_date_ex(class_type, (php_date_obj **)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2496] == 0) {
    {
    fprintf(_coverage_fout, "2496\n");
    fflush(_coverage_fout);
    ___coverage_array[2496] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
static zend_object_value date_object_clone_date(zval *this_ptr ) 
{ php_date_obj *new_obj ;
  php_date_obj *old_obj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_value new_ov ;
  zend_object_value tmp___0 ;
  void *tmp___1 ;
  size_t __len ;
  size_t tmp___2 ;
  char *__retval ;
  void *tmp___3 ;
  void *tmp___4 ;
  char *tmp___5 ;
  char *tmp___6 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2502] == 0) {
    {
    fprintf(_coverage_fout, "2502\n");
    fflush(_coverage_fout);
    ___coverage_array[2502] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj = (php_date_obj *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2503] == 0) {
    {
    fprintf(_coverage_fout, "2503\n");
    fflush(_coverage_fout);
    ___coverage_array[2503] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)this_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2504] == 0) {
    {
    fprintf(_coverage_fout, "2504\n");
    fflush(_coverage_fout);
    ___coverage_array[2504] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  old_obj = (php_date_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2505] == 0) {
    {
    fprintf(_coverage_fout, "2505\n");
    fflush(_coverage_fout);
    ___coverage_array[2505] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = date_object_new_date_ex(old_obj->std.ce, & new_obj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2506] == 0) {
    {
    fprintf(_coverage_fout, "2506\n");
    fflush(_coverage_fout);
    ___coverage_array[2506] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_ov = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2507] == 0) {
    {
    fprintf(_coverage_fout, "2507\n");
    fflush(_coverage_fout);
    ___coverage_array[2507] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_objects_clone_members(& new_obj->std, new_ov, & old_obj->std,
                             this_ptr->value.obj.handle);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2508] == 0) {
    {
    fprintf(_coverage_fout, "2508\n");
    fflush(_coverage_fout);
    ___coverage_array[2508] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj->time = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2509] == 0) {
    {
    fprintf(_coverage_fout, "2509\n");
    fflush(_coverage_fout);
    ___coverage_array[2509] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *(new_obj->time) = *(old_obj->time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2510] == 0) {
    {
    fprintf(_coverage_fout, "2510\n");
    fflush(_coverage_fout);
    ___coverage_array[2510] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((old_obj->time)->tz_abbr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2497] == 0) {
      {
      fprintf(_coverage_fout, "2497\n");
      fflush(_coverage_fout);
      ___coverage_array[2497] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = __strdup((char const   *)(old_obj->time)->tz_abbr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2498] == 0) {
      {
      fprintf(_coverage_fout, "2498\n");
      fflush(_coverage_fout);
      ___coverage_array[2498] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (new_obj->time)->tz_abbr = tmp___6;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2499] == 0) {
      {
      fprintf(_coverage_fout, "2499\n");
      fflush(_coverage_fout);
      ___coverage_array[2499] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2511] == 0) {
    {
    fprintf(_coverage_fout, "2511\n");
    fflush(_coverage_fout);
    ___coverage_array[2511] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((old_obj->time)->tz_info) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2500] == 0) {
      {
      fprintf(_coverage_fout, "2500\n");
      fflush(_coverage_fout);
      ___coverage_array[2500] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (new_obj->time)->tz_info = (old_obj->time)->tz_info;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2501] == 0) {
      {
      fprintf(_coverage_fout, "2501\n");
      fflush(_coverage_fout);
      ___coverage_array[2501] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2512] == 0) {
    {
    fprintf(_coverage_fout, "2512\n");
    fflush(_coverage_fout);
    ___coverage_array[2512] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (new_ov);
}
}
static int date_object_compare_date(zval *d1 , zval *d2 ) 
{ php_date_obj *o1 ;
  void __attribute__((__visibility__("default")))  *tmp ;
  php_date_obj *o2 ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___3 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___4 ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp___5 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___6 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2541] == 0) {
    {
    fprintf(_coverage_fout, "2541\n");
    fflush(_coverage_fout);
    ___coverage_array[2541] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )d1->type == 5) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2539] == 0) {
      {
      fprintf(_coverage_fout, "2539\n");
      fflush(_coverage_fout);
      ___coverage_array[2539] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )d2->type == 5) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2535] == 0) {
        {
        fprintf(_coverage_fout, "2535\n");
        fflush(_coverage_fout);
        ___coverage_array[2535] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___3 = zend_get_class_entry((zval const   *)d1);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2536] == 0) {
        {
        fprintf(_coverage_fout, "2536\n");
        fflush(_coverage_fout);
        ___coverage_array[2536] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = instanceof_function((zend_class_entry const   *)tmp___3,
                                    (zend_class_entry const   *)date_ce_date);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2537] == 0) {
        {
        fprintf(_coverage_fout, "2537\n");
        fflush(_coverage_fout);
        ___coverage_array[2537] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___4) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2531] == 0) {
          {
          fprintf(_coverage_fout, "2531\n");
          fflush(_coverage_fout);
          ___coverage_array[2531] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = zend_get_class_entry((zval const   *)d2);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2532] == 0) {
          {
          fprintf(_coverage_fout, "2532\n");
          fflush(_coverage_fout);
          ___coverage_array[2532] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___6 = instanceof_function((zend_class_entry const   *)tmp___5,
                                      (zend_class_entry const   *)date_ce_date);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2533] == 0) {
          {
          fprintf(_coverage_fout, "2533\n");
          fflush(_coverage_fout);
          ___coverage_array[2533] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___6) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2522] == 0) {
            {
            fprintf(_coverage_fout, "2522\n");
            fflush(_coverage_fout);
            ___coverage_array[2522] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp = zend_object_store_get_object((zval const   *)d1);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2523] == 0) {
            {
            fprintf(_coverage_fout, "2523\n");
            fflush(_coverage_fout);
            ___coverage_array[2523] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          o1 = (php_date_obj *)tmp;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2524] == 0) {
            {
            fprintf(_coverage_fout, "2524\n");
            fflush(_coverage_fout);
            ___coverage_array[2524] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___0 = zend_object_store_get_object((zval const   *)d2);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2525] == 0) {
            {
            fprintf(_coverage_fout, "2525\n");
            fflush(_coverage_fout);
            ___coverage_array[2525] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          o2 = (php_date_obj *)tmp___0;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2526] == 0) {
            {
            fprintf(_coverage_fout, "2526\n");
            fflush(_coverage_fout);
            ___coverage_array[2526] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (! (o1->time)->sse_uptodate) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2513] == 0) {
              {
              fprintf(_coverage_fout, "2513\n");
              fflush(_coverage_fout);
              ___coverage_array[2513] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            timelib_update_ts(o1->time, (o1->time)->tz_info);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2514] == 0) {
              {
              fprintf(_coverage_fout, "2514\n");
              fflush(_coverage_fout);
              ___coverage_array[2514] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2527] == 0) {
            {
            fprintf(_coverage_fout, "2527\n");
            fflush(_coverage_fout);
            ___coverage_array[2527] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (! (o2->time)->sse_uptodate) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2515] == 0) {
              {
              fprintf(_coverage_fout, "2515\n");
              fflush(_coverage_fout);
              ___coverage_array[2515] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            timelib_update_ts(o2->time, (o2->time)->tz_info);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2516] == 0) {
              {
              fprintf(_coverage_fout, "2516\n");
              fflush(_coverage_fout);
              ___coverage_array[2516] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2528] == 0) {
            {
            fprintf(_coverage_fout, "2528\n");
            fflush(_coverage_fout);
            ___coverage_array[2528] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if ((o1->time)->sse == (o2->time)->sse) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2517] == 0) {
              {
              fprintf(_coverage_fout, "2517\n");
              fflush(_coverage_fout);
              ___coverage_array[2517] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___2 = 0;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2520] == 0) {
              {
              fprintf(_coverage_fout, "2520\n");
              fflush(_coverage_fout);
              ___coverage_array[2520] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if ((o1->time)->sse < (o2->time)->sse) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[2518] == 0) {
                {
                fprintf(_coverage_fout, "2518\n");
                fflush(_coverage_fout);
                ___coverage_array[2518] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___1 = -1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[2519] == 0) {
                {
                fprintf(_coverage_fout, "2519\n");
                fflush(_coverage_fout);
                ___coverage_array[2519] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___1 = 1;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[2521] == 0) {
              {
              fprintf(_coverage_fout, "2521\n");
              fflush(_coverage_fout);
              ___coverage_array[2521] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___2 = tmp___1;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2529] == 0) {
            {
            fprintf(_coverage_fout, "2529\n");
            fflush(_coverage_fout);
            ___coverage_array[2529] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          return (tmp___2);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2530] == 0) {
            {
            fprintf(_coverage_fout, "2530\n");
            fflush(_coverage_fout);
            ___coverage_array[2530] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2534] == 0) {
          {
          fprintf(_coverage_fout, "2534\n");
          fflush(_coverage_fout);
          ___coverage_array[2534] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2538] == 0) {
        {
        fprintf(_coverage_fout, "2538\n");
        fflush(_coverage_fout);
        ___coverage_array[2538] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2540] == 0) {
      {
      fprintf(_coverage_fout, "2540\n");
      fflush(_coverage_fout);
      ___coverage_array[2540] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2542] == 0) {
    {
    fprintf(_coverage_fout, "2542\n");
    fflush(_coverage_fout);
    ___coverage_array[2542] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (1);
}
}
static HashTable *date_object_get_properties(zval *object ) 
{ HashTable *props ;
  zval *zv ;
  php_date_obj *dateobj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  HashTable __attribute__((__visibility__("default")))  *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  char const   *__s ;
  char *tmp___2 ;
  zval *__z ;
  size_t tmp___3 ;
  char __attribute__((__visibility__("default")))  *tmp___4 ;
  void __attribute__((__visibility__("default")))  *tmp___5 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___6 ;
  char const   *__s___0 ;
  zval *__z___1 ;
  size_t tmp___7 ;
  char __attribute__((__visibility__("default")))  *tmp___8 ;
  char *tmpstr ;
  void __attribute__((__visibility__("default")))  *tmp___9 ;
  timelib_sll utc_offset ;
  int tmp___10 ;
  int tmp___11 ;
  int tmp___12 ;
  char const   *__s___1 ;
  zval *__z___2 ;
  size_t tmp___13 ;
  char __attribute__((__visibility__("default")))  *tmp___14 ;
  char const   *__s___2 ;
  zval *__z___3 ;
  size_t tmp___15 ;
  char __attribute__((__visibility__("default")))  *tmp___16 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2607] == 0) {
    {
    fprintf(_coverage_fout, "2607\n");
    fflush(_coverage_fout);
    ___coverage_array[2607] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2608] == 0) {
    {
    fprintf(_coverage_fout, "2608\n");
    fflush(_coverage_fout);
    ___coverage_array[2608] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2609] == 0) {
    {
    fprintf(_coverage_fout, "2609\n");
    fflush(_coverage_fout);
    ___coverage_array[2609] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_std_get_properties(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2610] == 0) {
    {
    fprintf(_coverage_fout, "2610\n");
    fflush(_coverage_fout);
    ___coverage_array[2610] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  props = (HashTable *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2611] == 0) {
    {
    fprintf(_coverage_fout, "2611\n");
    fflush(_coverage_fout);
    ___coverage_array[2611] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2543] == 0) {
      {
      fprintf(_coverage_fout, "2543\n");
      fflush(_coverage_fout);
      ___coverage_array[2543] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (props);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2546] == 0) {
      {
      fprintf(_coverage_fout, "2546\n");
      fflush(_coverage_fout);
      ___coverage_array[2546] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (gc_globals.gc_active) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2544] == 0) {
        {
        fprintf(_coverage_fout, "2544\n");
        fflush(_coverage_fout);
        ___coverage_array[2544] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (props);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2545] == 0) {
        {
        fprintf(_coverage_fout, "2545\n");
        fflush(_coverage_fout);
        ___coverage_array[2545] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2612] == 0) {
    {
    fprintf(_coverage_fout, "2612\n");
    fflush(_coverage_fout);
    ___coverage_array[2612] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2547] == 0) {
      {
      fprintf(_coverage_fout, "2547\n");
      fflush(_coverage_fout);
      ___coverage_array[2547] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2548] == 0) {
      {
      fprintf(_coverage_fout, "2548\n");
      fflush(_coverage_fout);
      ___coverage_array[2548] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2549] == 0) {
      {
      fprintf(_coverage_fout, "2549\n");
      fflush(_coverage_fout);
      ___coverage_array[2549] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2613] == 0) {
    {
    fprintf(_coverage_fout, "2613\n");
    fflush(_coverage_fout);
    ___coverage_array[2613] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2614] == 0) {
    {
    fprintf(_coverage_fout, "2614\n");
    fflush(_coverage_fout);
    ___coverage_array[2614] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2615] == 0) {
    {
    fprintf(_coverage_fout, "2615\n");
    fflush(_coverage_fout);
    ___coverage_array[2615] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2550] == 0) {
      {
      fprintf(_coverage_fout, "2550\n");
      fflush(_coverage_fout);
      ___coverage_array[2550] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = date_format((char *)"Y-m-d H:i:s", 12, dateobj->time, 1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2551] == 0) {
      {
      fprintf(_coverage_fout, "2551\n");
      fflush(_coverage_fout);
      ___coverage_array[2551] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2552] == 0) {
      {
      fprintf(_coverage_fout, "2552\n");
      fflush(_coverage_fout);
      ___coverage_array[2552] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z = zv;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2553] == 0) {
      {
      fprintf(_coverage_fout, "2553\n");
      fflush(_coverage_fout);
      ___coverage_array[2553] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2554] == 0) {
      {
      fprintf(_coverage_fout, "2554\n");
      fflush(_coverage_fout);
      ___coverage_array[2554] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.len = (int )tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2555] == 0) {
      {
      fprintf(_coverage_fout, "2555\n");
      fflush(_coverage_fout);
      ___coverage_array[2555] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2556] == 0) {
      {
      fprintf(_coverage_fout, "2556\n");
      fflush(_coverage_fout);
      ___coverage_array[2556] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2616] == 0) {
    {
    fprintf(_coverage_fout, "2616\n");
    fflush(_coverage_fout);
    ___coverage_array[2616] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "date", 5U, (void *)(& zv), sizeof(zval ),
                           (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2617] == 0) {
    {
    fprintf(_coverage_fout, "2617\n");
    fflush(_coverage_fout);
    ___coverage_array[2617] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((dateobj->time)->is_localtime) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2595] == 0) {
      {
      fprintf(_coverage_fout, "2595\n");
      fflush(_coverage_fout);
      ___coverage_array[2595] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2557] == 0) {
        {
        fprintf(_coverage_fout, "2557\n");
        fflush(_coverage_fout);
        ___coverage_array[2557] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2558] == 0) {
        {
        fprintf(_coverage_fout, "2558\n");
        fflush(_coverage_fout);
        ___coverage_array[2558] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zv = (zval *)tmp___5;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2559] == 0) {
        {
        fprintf(_coverage_fout, "2559\n");
        fflush(_coverage_fout);
        ___coverage_array[2559] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2596] == 0) {
      {
      fprintf(_coverage_fout, "2596\n");
      fflush(_coverage_fout);
      ___coverage_array[2596] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2597] == 0) {
      {
      fprintf(_coverage_fout, "2597\n");
      fflush(_coverage_fout);
      ___coverage_array[2597] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2598] == 0) {
      {
      fprintf(_coverage_fout, "2598\n");
      fflush(_coverage_fout);
      ___coverage_array[2598] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0 = zv;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2599] == 0) {
      {
      fprintf(_coverage_fout, "2599\n");
      fflush(_coverage_fout);
      ___coverage_array[2599] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.lval = (long )(dateobj->time)->zone_type;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2600] == 0) {
      {
      fprintf(_coverage_fout, "2600\n");
      fflush(_coverage_fout);
      ___coverage_array[2600] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->type = (unsigned char)1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2601] == 0) {
      {
      fprintf(_coverage_fout, "2601\n");
      fflush(_coverage_fout);
      ___coverage_array[2601] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_add_or_update(props, "timezone_type", 14U, (void *)(& zv),
                             sizeof(zval ), (void **)((void *)0), 1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2602] == 0) {
      {
      fprintf(_coverage_fout, "2602\n");
      fflush(_coverage_fout);
      ___coverage_array[2602] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2560] == 0) {
        {
        fprintf(_coverage_fout, "2560\n");
        fflush(_coverage_fout);
        ___coverage_array[2560] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2561] == 0) {
        {
        fprintf(_coverage_fout, "2561\n");
        fflush(_coverage_fout);
        ___coverage_array[2561] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zv = (zval *)tmp___6;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2562] == 0) {
        {
        fprintf(_coverage_fout, "2562\n");
        fflush(_coverage_fout);
        ___coverage_array[2562] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2603] == 0) {
      {
      fprintf(_coverage_fout, "2603\n");
      fflush(_coverage_fout);
      ___coverage_array[2603] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2604] == 0) {
      {
      fprintf(_coverage_fout, "2604\n");
      fflush(_coverage_fout);
      ___coverage_array[2604] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->is_ref__gc = (unsigned char)0;
    switch ((int )(dateobj->time)->zone_type) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2585] == 0) {
      {
      fprintf(_coverage_fout, "2585\n");
      fflush(_coverage_fout);
      ___coverage_array[2585] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 3: 
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2563] == 0) {
        {
        fprintf(_coverage_fout, "2563\n");
        fflush(_coverage_fout);
        ___coverage_array[2563] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s___0 = (char const   *)((dateobj->time)->tz_info)->name;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2564] == 0) {
        {
        fprintf(_coverage_fout, "2564\n");
        fflush(_coverage_fout);
        ___coverage_array[2564] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = zv;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2565] == 0) {
        {
        fprintf(_coverage_fout, "2565\n");
        fflush(_coverage_fout);
        ___coverage_array[2565] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___7 = strlen(__s___0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2566] == 0) {
        {
        fprintf(_coverage_fout, "2566\n");
        fflush(_coverage_fout);
        ___coverage_array[2566] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.str.len = (int )tmp___7;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2567] == 0) {
        {
        fprintf(_coverage_fout, "2567\n");
        fflush(_coverage_fout);
        ___coverage_array[2567] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___8 = _estrndup(__s___0, (unsigned int )__z___1->value.str.len);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2568] == 0) {
        {
        fprintf(_coverage_fout, "2568\n");
        fflush(_coverage_fout);
        ___coverage_array[2568] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.str.val = (char *)tmp___8;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2569] == 0) {
        {
        fprintf(_coverage_fout, "2569\n");
        fflush(_coverage_fout);
        ___coverage_array[2569] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)6;
      break;
    }
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2586] == 0) {
      {
      fprintf(_coverage_fout, "2586\n");
      fflush(_coverage_fout);
      ___coverage_array[2586] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 1: 
    tmp___9 = _emalloc(sizeof("UTC+05:00"));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2587] == 0) {
      {
      fprintf(_coverage_fout, "2587\n");
      fflush(_coverage_fout);
      ___coverage_array[2587] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmpstr = (char *)tmp___9;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2588] == 0) {
      {
      fprintf(_coverage_fout, "2588\n");
      fflush(_coverage_fout);
      ___coverage_array[2588] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    utc_offset = (timelib_sll )(dateobj->time)->z;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2589] == 0) {
      {
      fprintf(_coverage_fout, "2589\n");
      fflush(_coverage_fout);
      ___coverage_array[2589] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = abs((int )(utc_offset % 60LL));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2590] == 0) {
      {
      fprintf(_coverage_fout, "2590\n");
      fflush(_coverage_fout);
      ___coverage_array[2590] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___11 = abs((int )(utc_offset / 60LL));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2591] == 0) {
      {
      fprintf(_coverage_fout, "2591\n");
      fflush(_coverage_fout);
      ___coverage_array[2591] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (utc_offset > 0LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2570] == 0) {
        {
        fprintf(_coverage_fout, "2570\n");
        fflush(_coverage_fout);
        ___coverage_array[2570] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___12 = '-';
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2571] == 0) {
        {
        fprintf(_coverage_fout, "2571\n");
        fflush(_coverage_fout);
        ___coverage_array[2571] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___12 = '+';
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2592] == 0) {
      {
      fprintf(_coverage_fout, "2592\n");
      fflush(_coverage_fout);
      ___coverage_array[2592] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ap_php_snprintf(tmpstr, sizeof("+05:00"), "%c%02d:%02d", tmp___12, tmp___11,
                    tmp___10);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2593] == 0) {
      {
      fprintf(_coverage_fout, "2593\n");
      fflush(_coverage_fout);
      ___coverage_array[2593] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2572] == 0) {
        {
        fprintf(_coverage_fout, "2572\n");
        fflush(_coverage_fout);
        ___coverage_array[2572] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s___1 = (char const   *)tmpstr;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2573] == 0) {
        {
        fprintf(_coverage_fout, "2573\n");
        fflush(_coverage_fout);
        ___coverage_array[2573] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2 = zv;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2574] == 0) {
        {
        fprintf(_coverage_fout, "2574\n");
        fflush(_coverage_fout);
        ___coverage_array[2574] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___13 = strlen(__s___1);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2575] == 0) {
        {
        fprintf(_coverage_fout, "2575\n");
        fflush(_coverage_fout);
        ___coverage_array[2575] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->value.str.len = (int )tmp___13;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2576] == 0) {
        {
        fprintf(_coverage_fout, "2576\n");
        fflush(_coverage_fout);
        ___coverage_array[2576] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s___1));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2577] == 0) {
        {
        fprintf(_coverage_fout, "2577\n");
        fflush(_coverage_fout);
        ___coverage_array[2577] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->type = (unsigned char)6;
      break;
    }
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2594] == 0) {
      {
      fprintf(_coverage_fout, "2594\n");
      fflush(_coverage_fout);
      ___coverage_array[2594] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 2: 
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2578] == 0) {
        {
        fprintf(_coverage_fout, "2578\n");
        fflush(_coverage_fout);
        ___coverage_array[2578] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s___2 = (char const   *)(dateobj->time)->tz_abbr;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2579] == 0) {
        {
        fprintf(_coverage_fout, "2579\n");
        fflush(_coverage_fout);
        ___coverage_array[2579] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___3 = zv;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2580] == 0) {
        {
        fprintf(_coverage_fout, "2580\n");
        fflush(_coverage_fout);
        ___coverage_array[2580] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___15 = strlen(__s___2);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2581] == 0) {
        {
        fprintf(_coverage_fout, "2581\n");
        fflush(_coverage_fout);
        ___coverage_array[2581] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___3->value.str.len = (int )tmp___15;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2582] == 0) {
        {
        fprintf(_coverage_fout, "2582\n");
        fflush(_coverage_fout);
        ___coverage_array[2582] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___16 = _estrndup(__s___2, (unsigned int )__z___3->value.str.len);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2583] == 0) {
        {
        fprintf(_coverage_fout, "2583\n");
        fflush(_coverage_fout);
        ___coverage_array[2583] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___3->value.str.val = (char *)tmp___16;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2584] == 0) {
        {
        fprintf(_coverage_fout, "2584\n");
        fflush(_coverage_fout);
        ___coverage_array[2584] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___3->type = (unsigned char)6;
      break;
    }
    break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2605] == 0) {
      {
      fprintf(_coverage_fout, "2605\n");
      fflush(_coverage_fout);
      ___coverage_array[2605] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_add_or_update(props, "timezone", 9U, (void *)(& zv),
                             sizeof(zval ), (void **)((void *)0), 1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2606] == 0) {
      {
      fprintf(_coverage_fout, "2606\n");
      fflush(_coverage_fout);
      ___coverage_array[2606] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2618] == 0) {
    {
    fprintf(_coverage_fout, "2618\n");
    fflush(_coverage_fout);
    ___coverage_array[2618] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (props);
}
}
__inline static zend_object_value date_object_new_timezone_ex(zend_class_entry *class_type ,
                                                              php_timezone_obj **ptr ) 
{ php_timezone_obj *intern ;
  zend_object_value retval ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_handle __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2621] == 0) {
    {
    fprintf(_coverage_fout, "2621\n");
    fflush(_coverage_fout);
    ___coverage_array[2621] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(php_timezone_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2622] == 0) {
    {
    fprintf(_coverage_fout, "2622\n");
    fflush(_coverage_fout);
    ___coverage_array[2622] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_timezone_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2623] == 0) {
    {
    fprintf(_coverage_fout, "2623\n");
    fflush(_coverage_fout);
    ___coverage_array[2623] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset((void *)intern, 0, sizeof(php_timezone_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2624] == 0) {
    {
    fprintf(_coverage_fout, "2624\n");
    fflush(_coverage_fout);
    ___coverage_array[2624] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2619] == 0) {
      {
      fprintf(_coverage_fout, "2619\n");
      fflush(_coverage_fout);
      ___coverage_array[2619] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *ptr = intern;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2620] == 0) {
      {
      fprintf(_coverage_fout, "2620\n");
      fflush(_coverage_fout);
      ___coverage_array[2620] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2625] == 0) {
    {
    fprintf(_coverage_fout, "2625\n");
    fflush(_coverage_fout);
    ___coverage_array[2625] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2626] == 0) {
    {
    fprintf(_coverage_fout, "2626\n");
    fflush(_coverage_fout);
    ___coverage_array[2626] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object_properties_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2627] == 0) {
    {
    fprintf(_coverage_fout, "2627\n");
    fflush(_coverage_fout);
    ___coverage_array[2627] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_objects_store_put((void *)intern,
                                   (void (*)(void *object ,
                                             zend_object_handle handle ))(& zend_objects_destroy_object),
                                   & date_object_free_storage_timezone,
                                   (void (*)(void *object , void **object_clone ))((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2628] == 0) {
    {
    fprintf(_coverage_fout, "2628\n");
    fflush(_coverage_fout);
    ___coverage_array[2628] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handle = (unsigned int )tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2629] == 0) {
    {
    fprintf(_coverage_fout, "2629\n");
    fflush(_coverage_fout);
    ___coverage_array[2629] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handlers = & date_object_handlers_timezone;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2630] == 0) {
    {
    fprintf(_coverage_fout, "2630\n");
    fflush(_coverage_fout);
    ___coverage_array[2630] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
static zend_object_value date_object_new_timezone(zend_class_entry *class_type ) 
{ zend_object_value tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2631] == 0) {
    {
    fprintf(_coverage_fout, "2631\n");
    fflush(_coverage_fout);
    ___coverage_array[2631] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = date_object_new_timezone_ex(class_type, (php_timezone_obj **)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2632] == 0) {
    {
    fprintf(_coverage_fout, "2632\n");
    fflush(_coverage_fout);
    ___coverage_array[2632] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
static zend_object_value date_object_clone_timezone(zval *this_ptr ) 
{ php_timezone_obj *new_obj ;
  php_timezone_obj *old_obj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_value new_ov ;
  zend_object_value tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2638] == 0) {
    {
    fprintf(_coverage_fout, "2638\n");
    fflush(_coverage_fout);
    ___coverage_array[2638] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj = (php_timezone_obj *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2639] == 0) {
    {
    fprintf(_coverage_fout, "2639\n");
    fflush(_coverage_fout);
    ___coverage_array[2639] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)this_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2640] == 0) {
    {
    fprintf(_coverage_fout, "2640\n");
    fflush(_coverage_fout);
    ___coverage_array[2640] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  old_obj = (php_timezone_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2641] == 0) {
    {
    fprintf(_coverage_fout, "2641\n");
    fflush(_coverage_fout);
    ___coverage_array[2641] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = date_object_new_timezone_ex(old_obj->std.ce, & new_obj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2642] == 0) {
    {
    fprintf(_coverage_fout, "2642\n");
    fflush(_coverage_fout);
    ___coverage_array[2642] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_ov = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2643] == 0) {
    {
    fprintf(_coverage_fout, "2643\n");
    fflush(_coverage_fout);
    ___coverage_array[2643] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_objects_clone_members(& new_obj->std, new_ov, & old_obj->std,
                             this_ptr->value.obj.handle);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2644] == 0) {
    {
    fprintf(_coverage_fout, "2644\n");
    fflush(_coverage_fout);
    ___coverage_array[2644] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj->type = old_obj->type;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2645] == 0) {
    {
    fprintf(_coverage_fout, "2645\n");
    fflush(_coverage_fout);
    ___coverage_array[2645] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj->initialized = 1;
  switch (new_obj->type) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2633] == 0) {
    {
    fprintf(_coverage_fout, "2633\n");
    fflush(_coverage_fout);
    ___coverage_array[2633] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  new_obj->tzi.tz = old_obj->tzi.tz;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2634] == 0) {
    {
    fprintf(_coverage_fout, "2634\n");
    fflush(_coverage_fout);
    ___coverage_array[2634] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  new_obj->tzi.utc_offset = old_obj->tzi.utc_offset;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2635] == 0) {
    {
    fprintf(_coverage_fout, "2635\n");
    fflush(_coverage_fout);
    ___coverage_array[2635] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  new_obj->tzi.z.utc_offset = old_obj->tzi.z.utc_offset;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2636] == 0) {
    {
    fprintf(_coverage_fout, "2636\n");
    fflush(_coverage_fout);
    ___coverage_array[2636] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj->tzi.z.dst = old_obj->tzi.z.dst;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2637] == 0) {
    {
    fprintf(_coverage_fout, "2637\n");
    fflush(_coverage_fout);
    ___coverage_array[2637] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj->tzi.z.abbr = old_obj->tzi.z.abbr;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2646] == 0) {
    {
    fprintf(_coverage_fout, "2646\n");
    fflush(_coverage_fout);
    ___coverage_array[2646] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (new_ov);
}
}
__inline static zend_object_value date_object_new_interval_ex(zend_class_entry *class_type ,
                                                              php_interval_obj **ptr ) 
{ php_interval_obj *intern ;
  zend_object_value retval ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_handle __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2649] == 0) {
    {
    fprintf(_coverage_fout, "2649\n");
    fflush(_coverage_fout);
    ___coverage_array[2649] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(php_interval_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2650] == 0) {
    {
    fprintf(_coverage_fout, "2650\n");
    fflush(_coverage_fout);
    ___coverage_array[2650] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_interval_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2651] == 0) {
    {
    fprintf(_coverage_fout, "2651\n");
    fflush(_coverage_fout);
    ___coverage_array[2651] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset((void *)intern, 0, sizeof(php_interval_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2652] == 0) {
    {
    fprintf(_coverage_fout, "2652\n");
    fflush(_coverage_fout);
    ___coverage_array[2652] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2647] == 0) {
      {
      fprintf(_coverage_fout, "2647\n");
      fflush(_coverage_fout);
      ___coverage_array[2647] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *ptr = intern;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2648] == 0) {
      {
      fprintf(_coverage_fout, "2648\n");
      fflush(_coverage_fout);
      ___coverage_array[2648] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2653] == 0) {
    {
    fprintf(_coverage_fout, "2653\n");
    fflush(_coverage_fout);
    ___coverage_array[2653] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2654] == 0) {
    {
    fprintf(_coverage_fout, "2654\n");
    fflush(_coverage_fout);
    ___coverage_array[2654] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object_properties_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2655] == 0) {
    {
    fprintf(_coverage_fout, "2655\n");
    fflush(_coverage_fout);
    ___coverage_array[2655] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_objects_store_put((void *)intern,
                                   (void (*)(void *object ,
                                             zend_object_handle handle ))(& zend_objects_destroy_object),
                                   & date_object_free_storage_interval,
                                   (void (*)(void *object , void **object_clone ))((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2656] == 0) {
    {
    fprintf(_coverage_fout, "2656\n");
    fflush(_coverage_fout);
    ___coverage_array[2656] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handle = (unsigned int )tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2657] == 0) {
    {
    fprintf(_coverage_fout, "2657\n");
    fflush(_coverage_fout);
    ___coverage_array[2657] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handlers = & date_object_handlers_interval;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2658] == 0) {
    {
    fprintf(_coverage_fout, "2658\n");
    fflush(_coverage_fout);
    ___coverage_array[2658] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
static zend_object_value date_object_new_interval(zend_class_entry *class_type ) 
{ zend_object_value tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2659] == 0) {
    {
    fprintf(_coverage_fout, "2659\n");
    fflush(_coverage_fout);
    ___coverage_array[2659] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = date_object_new_interval_ex(class_type, (php_interval_obj **)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2660] == 0) {
    {
    fprintf(_coverage_fout, "2660\n");
    fflush(_coverage_fout);
    ___coverage_array[2660] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
static zend_object_value date_object_clone_interval(zval *this_ptr ) 
{ php_interval_obj *new_obj ;
  php_interval_obj *old_obj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_value new_ov ;
  zend_object_value tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2661] == 0) {
    {
    fprintf(_coverage_fout, "2661\n");
    fflush(_coverage_fout);
    ___coverage_array[2661] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj = (php_interval_obj *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2662] == 0) {
    {
    fprintf(_coverage_fout, "2662\n");
    fflush(_coverage_fout);
    ___coverage_array[2662] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)this_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2663] == 0) {
    {
    fprintf(_coverage_fout, "2663\n");
    fflush(_coverage_fout);
    ___coverage_array[2663] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  old_obj = (php_interval_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2664] == 0) {
    {
    fprintf(_coverage_fout, "2664\n");
    fflush(_coverage_fout);
    ___coverage_array[2664] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = date_object_new_interval_ex(old_obj->std.ce, & new_obj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2665] == 0) {
    {
    fprintf(_coverage_fout, "2665\n");
    fflush(_coverage_fout);
    ___coverage_array[2665] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_ov = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2666] == 0) {
    {
    fprintf(_coverage_fout, "2666\n");
    fflush(_coverage_fout);
    ___coverage_array[2666] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_objects_clone_members(& new_obj->std, new_ov, & old_obj->std,
                             this_ptr->value.obj.handle);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2667] == 0) {
    {
    fprintf(_coverage_fout, "2667\n");
    fflush(_coverage_fout);
    ___coverage_array[2667] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (new_ov);
}
}
static HashTable *date_object_get_properties_interval(zval *object ) 
{ HashTable *props ;
  zval *zv ;
  php_interval_obj *intervalobj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  HashTable __attribute__((__visibility__("default")))  *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z ;
  size_t tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  zval *__z___0 ;
  size_t tmp___4 ;
  void __attribute__((__visibility__("default")))  *tmp___5 ;
  zval *__z___1 ;
  size_t tmp___6 ;
  void __attribute__((__visibility__("default")))  *tmp___7 ;
  zval *__z___2 ;
  size_t tmp___8 ;
  void __attribute__((__visibility__("default")))  *tmp___9 ;
  zval *__z___3 ;
  size_t tmp___10 ;
  void __attribute__((__visibility__("default")))  *tmp___11 ;
  zval *__z___4 ;
  size_t tmp___12 ;
  void __attribute__((__visibility__("default")))  *tmp___13 ;
  zval *__z___5 ;
  size_t tmp___14 ;
  void __attribute__((__visibility__("default")))  *tmp___15 ;
  zval *__z___6 ;
  size_t tmp___16 ;
  void __attribute__((__visibility__("default")))  *tmp___17 ;
  zval *__z___7 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2715] == 0) {
    {
    fprintf(_coverage_fout, "2715\n");
    fflush(_coverage_fout);
    ___coverage_array[2715] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2716] == 0) {
    {
    fprintf(_coverage_fout, "2716\n");
    fflush(_coverage_fout);
    ___coverage_array[2716] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intervalobj = (php_interval_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2717] == 0) {
    {
    fprintf(_coverage_fout, "2717\n");
    fflush(_coverage_fout);
    ___coverage_array[2717] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_std_get_properties(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2718] == 0) {
    {
    fprintf(_coverage_fout, "2718\n");
    fflush(_coverage_fout);
    ___coverage_array[2718] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  props = (HashTable *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2719] == 0) {
    {
    fprintf(_coverage_fout, "2719\n");
    fflush(_coverage_fout);
    ___coverage_array[2719] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! intervalobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2668] == 0) {
      {
      fprintf(_coverage_fout, "2668\n");
      fflush(_coverage_fout);
      ___coverage_array[2668] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (props);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2671] == 0) {
      {
      fprintf(_coverage_fout, "2671\n");
      fflush(_coverage_fout);
      ___coverage_array[2671] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (gc_globals.gc_active) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2669] == 0) {
        {
        fprintf(_coverage_fout, "2669\n");
        fflush(_coverage_fout);
        ___coverage_array[2669] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (props);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2670] == 0) {
        {
        fprintf(_coverage_fout, "2670\n");
        fflush(_coverage_fout);
        ___coverage_array[2670] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2720] == 0) {
    {
    fprintf(_coverage_fout, "2720\n");
    fflush(_coverage_fout);
    ___coverage_array[2720] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2672] == 0) {
      {
      fprintf(_coverage_fout, "2672\n");
      fflush(_coverage_fout);
      ___coverage_array[2672] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2673] == 0) {
      {
      fprintf(_coverage_fout, "2673\n");
      fflush(_coverage_fout);
      ___coverage_array[2673] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2674] == 0) {
      {
      fprintf(_coverage_fout, "2674\n");
      fflush(_coverage_fout);
      ___coverage_array[2674] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2721] == 0) {
    {
    fprintf(_coverage_fout, "2721\n");
    fflush(_coverage_fout);
    ___coverage_array[2721] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2722] == 0) {
    {
    fprintf(_coverage_fout, "2722\n");
    fflush(_coverage_fout);
    ___coverage_array[2722] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2723] == 0) {
    {
    fprintf(_coverage_fout, "2723\n");
    fflush(_coverage_fout);
    ___coverage_array[2723] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2724] == 0) {
    {
    fprintf(_coverage_fout, "2724\n");
    fflush(_coverage_fout);
    ___coverage_array[2724] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z->value.lval = (long )(intervalobj->diff)->y;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2725] == 0) {
    {
    fprintf(_coverage_fout, "2725\n");
    fflush(_coverage_fout);
    ___coverage_array[2725] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2726] == 0) {
    {
    fprintf(_coverage_fout, "2726\n");
    fflush(_coverage_fout);
    ___coverage_array[2726] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = strlen("y");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2727] == 0) {
    {
    fprintf(_coverage_fout, "2727\n");
    fflush(_coverage_fout);
    ___coverage_array[2727] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "y", tmp___2 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2728] == 0) {
    {
    fprintf(_coverage_fout, "2728\n");
    fflush(_coverage_fout);
    ___coverage_array[2728] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2675] == 0) {
      {
      fprintf(_coverage_fout, "2675\n");
      fflush(_coverage_fout);
      ___coverage_array[2675] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2676] == 0) {
      {
      fprintf(_coverage_fout, "2676\n");
      fflush(_coverage_fout);
      ___coverage_array[2676] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2677] == 0) {
      {
      fprintf(_coverage_fout, "2677\n");
      fflush(_coverage_fout);
      ___coverage_array[2677] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2729] == 0) {
    {
    fprintf(_coverage_fout, "2729\n");
    fflush(_coverage_fout);
    ___coverage_array[2729] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2730] == 0) {
    {
    fprintf(_coverage_fout, "2730\n");
    fflush(_coverage_fout);
    ___coverage_array[2730] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2731] == 0) {
    {
    fprintf(_coverage_fout, "2731\n");
    fflush(_coverage_fout);
    ___coverage_array[2731] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___0 = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2732] == 0) {
    {
    fprintf(_coverage_fout, "2732\n");
    fflush(_coverage_fout);
    ___coverage_array[2732] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___0->value.lval = (long )(intervalobj->diff)->m;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2733] == 0) {
    {
    fprintf(_coverage_fout, "2733\n");
    fflush(_coverage_fout);
    ___coverage_array[2733] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___0->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2734] == 0) {
    {
    fprintf(_coverage_fout, "2734\n");
    fflush(_coverage_fout);
    ___coverage_array[2734] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = strlen("m");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2735] == 0) {
    {
    fprintf(_coverage_fout, "2735\n");
    fflush(_coverage_fout);
    ___coverage_array[2735] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "m", tmp___4 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2736] == 0) {
    {
    fprintf(_coverage_fout, "2736\n");
    fflush(_coverage_fout);
    ___coverage_array[2736] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2678] == 0) {
      {
      fprintf(_coverage_fout, "2678\n");
      fflush(_coverage_fout);
      ___coverage_array[2678] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2679] == 0) {
      {
      fprintf(_coverage_fout, "2679\n");
      fflush(_coverage_fout);
      ___coverage_array[2679] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___5;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2680] == 0) {
      {
      fprintf(_coverage_fout, "2680\n");
      fflush(_coverage_fout);
      ___coverage_array[2680] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2737] == 0) {
    {
    fprintf(_coverage_fout, "2737\n");
    fflush(_coverage_fout);
    ___coverage_array[2737] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2738] == 0) {
    {
    fprintf(_coverage_fout, "2738\n");
    fflush(_coverage_fout);
    ___coverage_array[2738] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2739] == 0) {
    {
    fprintf(_coverage_fout, "2739\n");
    fflush(_coverage_fout);
    ___coverage_array[2739] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___1 = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2740] == 0) {
    {
    fprintf(_coverage_fout, "2740\n");
    fflush(_coverage_fout);
    ___coverage_array[2740] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___1->value.lval = (long )(intervalobj->diff)->d;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2741] == 0) {
    {
    fprintf(_coverage_fout, "2741\n");
    fflush(_coverage_fout);
    ___coverage_array[2741] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___1->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2742] == 0) {
    {
    fprintf(_coverage_fout, "2742\n");
    fflush(_coverage_fout);
    ___coverage_array[2742] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___6 = strlen("d");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2743] == 0) {
    {
    fprintf(_coverage_fout, "2743\n");
    fflush(_coverage_fout);
    ___coverage_array[2743] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "d", tmp___6 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2744] == 0) {
    {
    fprintf(_coverage_fout, "2744\n");
    fflush(_coverage_fout);
    ___coverage_array[2744] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2681] == 0) {
      {
      fprintf(_coverage_fout, "2681\n");
      fflush(_coverage_fout);
      ___coverage_array[2681] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2682] == 0) {
      {
      fprintf(_coverage_fout, "2682\n");
      fflush(_coverage_fout);
      ___coverage_array[2682] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___7;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2683] == 0) {
      {
      fprintf(_coverage_fout, "2683\n");
      fflush(_coverage_fout);
      ___coverage_array[2683] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2745] == 0) {
    {
    fprintf(_coverage_fout, "2745\n");
    fflush(_coverage_fout);
    ___coverage_array[2745] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2746] == 0) {
    {
    fprintf(_coverage_fout, "2746\n");
    fflush(_coverage_fout);
    ___coverage_array[2746] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2747] == 0) {
    {
    fprintf(_coverage_fout, "2747\n");
    fflush(_coverage_fout);
    ___coverage_array[2747] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2 = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2748] == 0) {
    {
    fprintf(_coverage_fout, "2748\n");
    fflush(_coverage_fout);
    ___coverage_array[2748] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->value.lval = (long )(intervalobj->diff)->h;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2749] == 0) {
    {
    fprintf(_coverage_fout, "2749\n");
    fflush(_coverage_fout);
    ___coverage_array[2749] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2750] == 0) {
    {
    fprintf(_coverage_fout, "2750\n");
    fflush(_coverage_fout);
    ___coverage_array[2750] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___8 = strlen("h");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2751] == 0) {
    {
    fprintf(_coverage_fout, "2751\n");
    fflush(_coverage_fout);
    ___coverage_array[2751] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "h", tmp___8 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2752] == 0) {
    {
    fprintf(_coverage_fout, "2752\n");
    fflush(_coverage_fout);
    ___coverage_array[2752] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2684] == 0) {
      {
      fprintf(_coverage_fout, "2684\n");
      fflush(_coverage_fout);
      ___coverage_array[2684] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2685] == 0) {
      {
      fprintf(_coverage_fout, "2685\n");
      fflush(_coverage_fout);
      ___coverage_array[2685] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___9;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2686] == 0) {
      {
      fprintf(_coverage_fout, "2686\n");
      fflush(_coverage_fout);
      ___coverage_array[2686] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2753] == 0) {
    {
    fprintf(_coverage_fout, "2753\n");
    fflush(_coverage_fout);
    ___coverage_array[2753] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2754] == 0) {
    {
    fprintf(_coverage_fout, "2754\n");
    fflush(_coverage_fout);
    ___coverage_array[2754] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2755] == 0) {
    {
    fprintf(_coverage_fout, "2755\n");
    fflush(_coverage_fout);
    ___coverage_array[2755] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___3 = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2756] == 0) {
    {
    fprintf(_coverage_fout, "2756\n");
    fflush(_coverage_fout);
    ___coverage_array[2756] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___3->value.lval = (long )(intervalobj->diff)->i;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2757] == 0) {
    {
    fprintf(_coverage_fout, "2757\n");
    fflush(_coverage_fout);
    ___coverage_array[2757] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___3->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2758] == 0) {
    {
    fprintf(_coverage_fout, "2758\n");
    fflush(_coverage_fout);
    ___coverage_array[2758] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___10 = strlen("i");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2759] == 0) {
    {
    fprintf(_coverage_fout, "2759\n");
    fflush(_coverage_fout);
    ___coverage_array[2759] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "i", tmp___10 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2760] == 0) {
    {
    fprintf(_coverage_fout, "2760\n");
    fflush(_coverage_fout);
    ___coverage_array[2760] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2687] == 0) {
      {
      fprintf(_coverage_fout, "2687\n");
      fflush(_coverage_fout);
      ___coverage_array[2687] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___11 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2688] == 0) {
      {
      fprintf(_coverage_fout, "2688\n");
      fflush(_coverage_fout);
      ___coverage_array[2688] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___11;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2689] == 0) {
      {
      fprintf(_coverage_fout, "2689\n");
      fflush(_coverage_fout);
      ___coverage_array[2689] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2761] == 0) {
    {
    fprintf(_coverage_fout, "2761\n");
    fflush(_coverage_fout);
    ___coverage_array[2761] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2762] == 0) {
    {
    fprintf(_coverage_fout, "2762\n");
    fflush(_coverage_fout);
    ___coverage_array[2762] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2763] == 0) {
    {
    fprintf(_coverage_fout, "2763\n");
    fflush(_coverage_fout);
    ___coverage_array[2763] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___4 = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2764] == 0) {
    {
    fprintf(_coverage_fout, "2764\n");
    fflush(_coverage_fout);
    ___coverage_array[2764] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___4->value.lval = (long )(intervalobj->diff)->s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2765] == 0) {
    {
    fprintf(_coverage_fout, "2765\n");
    fflush(_coverage_fout);
    ___coverage_array[2765] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___4->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2766] == 0) {
    {
    fprintf(_coverage_fout, "2766\n");
    fflush(_coverage_fout);
    ___coverage_array[2766] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___12 = strlen("s");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2767] == 0) {
    {
    fprintf(_coverage_fout, "2767\n");
    fflush(_coverage_fout);
    ___coverage_array[2767] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "s", tmp___12 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2768] == 0) {
    {
    fprintf(_coverage_fout, "2768\n");
    fflush(_coverage_fout);
    ___coverage_array[2768] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2690] == 0) {
      {
      fprintf(_coverage_fout, "2690\n");
      fflush(_coverage_fout);
      ___coverage_array[2690] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___13 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2691] == 0) {
      {
      fprintf(_coverage_fout, "2691\n");
      fflush(_coverage_fout);
      ___coverage_array[2691] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv = (zval *)tmp___13;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2692] == 0) {
      {
      fprintf(_coverage_fout, "2692\n");
      fflush(_coverage_fout);
      ___coverage_array[2692] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2769] == 0) {
    {
    fprintf(_coverage_fout, "2769\n");
    fflush(_coverage_fout);
    ___coverage_array[2769] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2770] == 0) {
    {
    fprintf(_coverage_fout, "2770\n");
    fflush(_coverage_fout);
    ___coverage_array[2770] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zv->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2771] == 0) {
    {
    fprintf(_coverage_fout, "2771\n");
    fflush(_coverage_fout);
    ___coverage_array[2771] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___5 = zv;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2772] == 0) {
    {
    fprintf(_coverage_fout, "2772\n");
    fflush(_coverage_fout);
    ___coverage_array[2772] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___5->value.lval = (long )(intervalobj->diff)->invert;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2773] == 0) {
    {
    fprintf(_coverage_fout, "2773\n");
    fflush(_coverage_fout);
    ___coverage_array[2773] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___5->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2774] == 0) {
    {
    fprintf(_coverage_fout, "2774\n");
    fflush(_coverage_fout);
    ___coverage_array[2774] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___14 = strlen("invert");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2775] == 0) {
    {
    fprintf(_coverage_fout, "2775\n");
    fflush(_coverage_fout);
    ___coverage_array[2775] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zend_hash_add_or_update(props, "invert", tmp___14 + 1U, (void *)(& zv),
                           sizeof(zval ), (void **)((void *)0), 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2776] == 0) {
    {
    fprintf(_coverage_fout, "2776\n");
    fflush(_coverage_fout);
    ___coverage_array[2776] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((intervalobj->diff)->days != -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2696] == 0) {
      {
      fprintf(_coverage_fout, "2696\n");
      fflush(_coverage_fout);
      ___coverage_array[2696] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2693] == 0) {
        {
        fprintf(_coverage_fout, "2693\n");
        fflush(_coverage_fout);
        ___coverage_array[2693] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___15 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2694] == 0) {
        {
        fprintf(_coverage_fout, "2694\n");
        fflush(_coverage_fout);
        ___coverage_array[2694] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zv = (zval *)tmp___15;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2695] == 0) {
        {
        fprintf(_coverage_fout, "2695\n");
        fflush(_coverage_fout);
        ___coverage_array[2695] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2697] == 0) {
      {
      fprintf(_coverage_fout, "2697\n");
      fflush(_coverage_fout);
      ___coverage_array[2697] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2698] == 0) {
      {
      fprintf(_coverage_fout, "2698\n");
      fflush(_coverage_fout);
      ___coverage_array[2698] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2699] == 0) {
      {
      fprintf(_coverage_fout, "2699\n");
      fflush(_coverage_fout);
      ___coverage_array[2699] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___6 = zv;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2700] == 0) {
      {
      fprintf(_coverage_fout, "2700\n");
      fflush(_coverage_fout);
      ___coverage_array[2700] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___6->value.lval = (long )(intervalobj->diff)->days;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2701] == 0) {
      {
      fprintf(_coverage_fout, "2701\n");
      fflush(_coverage_fout);
      ___coverage_array[2701] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___6->type = (unsigned char)1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2702] == 0) {
      {
      fprintf(_coverage_fout, "2702\n");
      fflush(_coverage_fout);
      ___coverage_array[2702] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___16 = strlen("days");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2703] == 0) {
      {
      fprintf(_coverage_fout, "2703\n");
      fflush(_coverage_fout);
      ___coverage_array[2703] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_add_or_update(props, "days", tmp___16 + 1U, (void *)(& zv),
                             sizeof(zval ), (void **)((void *)0), 1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2710] == 0) {
      {
      fprintf(_coverage_fout, "2710\n");
      fflush(_coverage_fout);
      ___coverage_array[2710] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2704] == 0) {
        {
        fprintf(_coverage_fout, "2704\n");
        fflush(_coverage_fout);
        ___coverage_array[2704] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___17 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2705] == 0) {
        {
        fprintf(_coverage_fout, "2705\n");
        fflush(_coverage_fout);
        ___coverage_array[2705] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      zv = (zval *)tmp___17;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2706] == 0) {
        {
        fprintf(_coverage_fout, "2706\n");
        fflush(_coverage_fout);
        ___coverage_array[2706] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)zv)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2711] == 0) {
      {
      fprintf(_coverage_fout, "2711\n");
      fflush(_coverage_fout);
      ___coverage_array[2711] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2712] == 0) {
      {
      fprintf(_coverage_fout, "2712\n");
      fflush(_coverage_fout);
      ___coverage_array[2712] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zv->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2713] == 0) {
      {
      fprintf(_coverage_fout, "2713\n");
      fflush(_coverage_fout);
      ___coverage_array[2713] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2707] == 0) {
        {
        fprintf(_coverage_fout, "2707\n");
        fflush(_coverage_fout);
        ___coverage_array[2707] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___7 = zv;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2708] == 0) {
        {
        fprintf(_coverage_fout, "2708\n");
        fflush(_coverage_fout);
        ___coverage_array[2708] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___7->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2709] == 0) {
        {
        fprintf(_coverage_fout, "2709\n");
        fflush(_coverage_fout);
        ___coverage_array[2709] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___7->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2714] == 0) {
      {
      fprintf(_coverage_fout, "2714\n");
      fflush(_coverage_fout);
      ___coverage_array[2714] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zend_hash_add_or_update(props, "days", 5U, (void *)(& zv), sizeof(zval ),
                             (void **)((void *)0), 1);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2777] == 0) {
    {
    fprintf(_coverage_fout, "2777\n");
    fflush(_coverage_fout);
    ___coverage_array[2777] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (props);
}
}
__inline static zend_object_value date_object_new_period_ex(zend_class_entry *class_type ,
                                                            php_period_obj **ptr ) 
{ php_period_obj *intern ;
  zend_object_value retval ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_handle __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2780] == 0) {
    {
    fprintf(_coverage_fout, "2780\n");
    fflush(_coverage_fout);
    ___coverage_array[2780] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = _emalloc(sizeof(php_period_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2781] == 0) {
    {
    fprintf(_coverage_fout, "2781\n");
    fflush(_coverage_fout);
    ___coverage_array[2781] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_period_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2782] == 0) {
    {
    fprintf(_coverage_fout, "2782\n");
    fflush(_coverage_fout);
    ___coverage_array[2782] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset((void *)intern, 0, sizeof(php_period_obj ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2783] == 0) {
    {
    fprintf(_coverage_fout, "2783\n");
    fflush(_coverage_fout);
    ___coverage_array[2783] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ptr) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2778] == 0) {
      {
      fprintf(_coverage_fout, "2778\n");
      fflush(_coverage_fout);
      ___coverage_array[2778] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *ptr = intern;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2779] == 0) {
      {
      fprintf(_coverage_fout, "2779\n");
      fflush(_coverage_fout);
      ___coverage_array[2779] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2784] == 0) {
    {
    fprintf(_coverage_fout, "2784\n");
    fflush(_coverage_fout);
    ___coverage_array[2784] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2785] == 0) {
    {
    fprintf(_coverage_fout, "2785\n");
    fflush(_coverage_fout);
    ___coverage_array[2785] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object_properties_init(& intern->std, class_type);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2786] == 0) {
    {
    fprintf(_coverage_fout, "2786\n");
    fflush(_coverage_fout);
    ___coverage_array[2786] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_objects_store_put((void *)intern,
                                   (void (*)(void *object ,
                                             zend_object_handle handle ))(& zend_objects_destroy_object),
                                   & date_object_free_storage_period,
                                   (void (*)(void *object , void **object_clone ))((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2787] == 0) {
    {
    fprintf(_coverage_fout, "2787\n");
    fflush(_coverage_fout);
    ___coverage_array[2787] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handle = (unsigned int )tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2788] == 0) {
    {
    fprintf(_coverage_fout, "2788\n");
    fflush(_coverage_fout);
    ___coverage_array[2788] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval.handlers = & date_object_handlers_period;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2789] == 0) {
    {
    fprintf(_coverage_fout, "2789\n");
    fflush(_coverage_fout);
    ___coverage_array[2789] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
static zend_object_value date_object_new_period(zend_class_entry *class_type ) 
{ zend_object_value tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2790] == 0) {
    {
    fprintf(_coverage_fout, "2790\n");
    fflush(_coverage_fout);
    ___coverage_array[2790] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = date_object_new_period_ex(class_type, (php_period_obj **)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2791] == 0) {
    {
    fprintf(_coverage_fout, "2791\n");
    fflush(_coverage_fout);
    ___coverage_array[2791] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (tmp);
}
}
static zend_object_value date_object_clone_period(zval *this_ptr ) 
{ php_period_obj *new_obj ;
  php_period_obj *old_obj ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zend_object_value new_ov ;
  zend_object_value tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2792] == 0) {
    {
    fprintf(_coverage_fout, "2792\n");
    fflush(_coverage_fout);
    ___coverage_array[2792] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_obj = (php_period_obj *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2793] == 0) {
    {
    fprintf(_coverage_fout, "2793\n");
    fflush(_coverage_fout);
    ___coverage_array[2793] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)this_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2794] == 0) {
    {
    fprintf(_coverage_fout, "2794\n");
    fflush(_coverage_fout);
    ___coverage_array[2794] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  old_obj = (php_period_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2795] == 0) {
    {
    fprintf(_coverage_fout, "2795\n");
    fflush(_coverage_fout);
    ___coverage_array[2795] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = date_object_new_period_ex(old_obj->std.ce, & new_obj);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2796] == 0) {
    {
    fprintf(_coverage_fout, "2796\n");
    fflush(_coverage_fout);
    ___coverage_array[2796] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  new_ov = tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2797] == 0) {
    {
    fprintf(_coverage_fout, "2797\n");
    fflush(_coverage_fout);
    ___coverage_array[2797] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_objects_clone_members(& new_obj->std, new_ov, & old_obj->std,
                             this_ptr->value.obj.handle);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2798] == 0) {
    {
    fprintf(_coverage_fout, "2798\n");
    fflush(_coverage_fout);
    ___coverage_array[2798] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (new_ov);
}
}
static void date_object_free_storage_date(void *object ) 
{ php_date_obj *intern ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2801] == 0) {
    {
    fprintf(_coverage_fout, "2801\n");
    fflush(_coverage_fout);
    ___coverage_array[2801] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_date_obj *)object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2802] == 0) {
    {
    fprintf(_coverage_fout, "2802\n");
    fflush(_coverage_fout);
    ___coverage_array[2802] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (intern->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2799] == 0) {
      {
      fprintf(_coverage_fout, "2799\n");
      fflush(_coverage_fout);
      ___coverage_array[2799] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(intern->time);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2800] == 0) {
      {
      fprintf(_coverage_fout, "2800\n");
      fflush(_coverage_fout);
      ___coverage_array[2800] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2803] == 0) {
    {
    fprintf(_coverage_fout, "2803\n");
    fflush(_coverage_fout);
    ___coverage_array[2803] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_dtor(& intern->std);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2804] == 0) {
    {
    fprintf(_coverage_fout, "2804\n");
    fflush(_coverage_fout);
    ___coverage_array[2804] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2805] == 0) {
    {
    fprintf(_coverage_fout, "2805\n");
    fflush(_coverage_fout);
    ___coverage_array[2805] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void date_object_free_storage_timezone(void *object ) 
{ php_timezone_obj *intern ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2808] == 0) {
    {
    fprintf(_coverage_fout, "2808\n");
    fflush(_coverage_fout);
    ___coverage_array[2808] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_timezone_obj *)object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2809] == 0) {
    {
    fprintf(_coverage_fout, "2809\n");
    fflush(_coverage_fout);
    ___coverage_array[2809] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (intern->type == 2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2806] == 0) {
      {
      fprintf(_coverage_fout, "2806\n");
      fflush(_coverage_fout);
      ___coverage_array[2806] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    free((void *)intern->tzi.z.abbr);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2807] == 0) {
      {
      fprintf(_coverage_fout, "2807\n");
      fflush(_coverage_fout);
      ___coverage_array[2807] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2810] == 0) {
    {
    fprintf(_coverage_fout, "2810\n");
    fflush(_coverage_fout);
    ___coverage_array[2810] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_dtor(& intern->std);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2811] == 0) {
    {
    fprintf(_coverage_fout, "2811\n");
    fflush(_coverage_fout);
    ___coverage_array[2811] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2812] == 0) {
    {
    fprintf(_coverage_fout, "2812\n");
    fflush(_coverage_fout);
    ___coverage_array[2812] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void date_object_free_storage_interval(void *object ) 
{ php_interval_obj *intern ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2813] == 0) {
    {
    fprintf(_coverage_fout, "2813\n");
    fflush(_coverage_fout);
    ___coverage_array[2813] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_interval_obj *)object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2814] == 0) {
    {
    fprintf(_coverage_fout, "2814\n");
    fflush(_coverage_fout);
    ___coverage_array[2814] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_rel_time_dtor(intern->diff);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2815] == 0) {
    {
    fprintf(_coverage_fout, "2815\n");
    fflush(_coverage_fout);
    ___coverage_array[2815] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_dtor(& intern->std);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2816] == 0) {
    {
    fprintf(_coverage_fout, "2816\n");
    fflush(_coverage_fout);
    ___coverage_array[2816] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2817] == 0) {
    {
    fprintf(_coverage_fout, "2817\n");
    fflush(_coverage_fout);
    ___coverage_array[2817] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void date_object_free_storage_period(void *object ) 
{ php_period_obj *intern ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2824] == 0) {
    {
    fprintf(_coverage_fout, "2824\n");
    fflush(_coverage_fout);
    ___coverage_array[2824] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intern = (php_period_obj *)object;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2825] == 0) {
    {
    fprintf(_coverage_fout, "2825\n");
    fflush(_coverage_fout);
    ___coverage_array[2825] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (intern->start) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2818] == 0) {
      {
      fprintf(_coverage_fout, "2818\n");
      fflush(_coverage_fout);
      ___coverage_array[2818] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(intern->start);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2819] == 0) {
      {
      fprintf(_coverage_fout, "2819\n");
      fflush(_coverage_fout);
      ___coverage_array[2819] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2826] == 0) {
    {
    fprintf(_coverage_fout, "2826\n");
    fflush(_coverage_fout);
    ___coverage_array[2826] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (intern->current) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2820] == 0) {
      {
      fprintf(_coverage_fout, "2820\n");
      fflush(_coverage_fout);
      ___coverage_array[2820] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(intern->current);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2821] == 0) {
      {
      fprintf(_coverage_fout, "2821\n");
      fflush(_coverage_fout);
      ___coverage_array[2821] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2827] == 0) {
    {
    fprintf(_coverage_fout, "2827\n");
    fflush(_coverage_fout);
    ___coverage_array[2827] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (intern->end) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2822] == 0) {
      {
      fprintf(_coverage_fout, "2822\n");
      fflush(_coverage_fout);
      ___coverage_array[2822] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(intern->end);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2823] == 0) {
      {
      fprintf(_coverage_fout, "2823\n");
      fflush(_coverage_fout);
      ___coverage_array[2823] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2828] == 0) {
    {
    fprintf(_coverage_fout, "2828\n");
    fflush(_coverage_fout);
    ___coverage_array[2828] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_rel_time_dtor(intern->interval);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2829] == 0) {
    {
    fprintf(_coverage_fout, "2829\n");
    fflush(_coverage_fout);
    ___coverage_array[2829] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_object_std_dtor(& intern->std);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2830] == 0) {
    {
    fprintf(_coverage_fout, "2830\n");
    fflush(_coverage_fout);
    ___coverage_array[2830] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _efree(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2831] == 0) {
    {
    fprintf(_coverage_fout, "2831\n");
    fflush(_coverage_fout);
    ___coverage_array[2831] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
zval __attribute__((__visibility__("default")))  *php_date_instantiate(zend_class_entry *pce ,
                                                                       zval *object ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2832] == 0) {
    {
    fprintf(_coverage_fout, "2832\n");
    fflush(_coverage_fout);
    ___coverage_array[2832] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object->type = (unsigned char)5;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2833] == 0) {
    {
    fprintf(_coverage_fout, "2833\n");
    fflush(_coverage_fout);
    ___coverage_array[2833] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _object_init_ex(object, pce);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2834] == 0) {
    {
    fprintf(_coverage_fout, "2834\n");
    fflush(_coverage_fout);
    ___coverage_array[2834] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(object, 1U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2835] == 0) {
    {
    fprintf(_coverage_fout, "2835\n");
    fflush(_coverage_fout);
    ___coverage_array[2835] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_unset_isref_p(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2836] == 0) {
    {
    fprintf(_coverage_fout, "2836\n");
    fflush(_coverage_fout);
    ___coverage_array[2836] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((zval __attribute__((__visibility__("default")))  *)object);
}
}
static void update_errors_warnings(timelib_error_container *last_errors ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2840] == 0) {
    {
    fprintf(_coverage_fout, "2840\n");
    fflush(_coverage_fout);
    ___coverage_array[2840] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.last_errors) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2837] == 0) {
      {
      fprintf(_coverage_fout, "2837\n");
      fflush(_coverage_fout);
      ___coverage_array[2837] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_error_container_dtor(date_globals.last_errors);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2838] == 0) {
      {
      fprintf(_coverage_fout, "2838\n");
      fflush(_coverage_fout);
      ___coverage_array[2838] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    date_globals.last_errors = (timelib_error_container *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2839] == 0) {
      {
      fprintf(_coverage_fout, "2839\n");
      fflush(_coverage_fout);
      ___coverage_array[2839] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2841] == 0) {
    {
    fprintf(_coverage_fout, "2841\n");
    fflush(_coverage_fout);
    ___coverage_array[2841] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.last_errors = last_errors;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2842] == 0) {
    {
    fprintf(_coverage_fout, "2842\n");
    fflush(_coverage_fout);
    ___coverage_array[2842] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
int __attribute__((__visibility__("default")))  php_date_initialize(php_date_obj *dateobj ,
                                                                    char *time_str ,
                                                                    int time_str_len ,
                                                                    char *format ,
                                                                    zval *timezone_object ,
                                                                    int ctor ) 
{ timelib_time *now ;
  timelib_tzinfo *tzi ;
  timelib_error_container *err ;
  int type ;
  int new_dst ;
  char *new_abbr ;
  timelib_sll new_offset ;
  timelib_tzdb const   *tmp ;
  timelib_tzdb const   *tmp___0 ;
  int tmp___1 ;
  char const   *tmp___2 ;
  timelib_tzdb const   *tmp___3 ;
  timelib_tzdb const   *tmp___4 ;
  unsigned int tmp___5 ;
  char const   *tmp___6 ;
  php_timezone_obj *tzobj ;
  void __attribute__((__visibility__("default")))  *tmp___7 ;
  void *tmp___8 ;
  size_t __len ;
  size_t tmp___9 ;
  char *__retval ;
  void *tmp___10 ;
  void *tmp___11 ;
  char *tmp___12 ;
  char *tmp___13 ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___14 ;
  time_t tmp___15 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2895] == 0) {
    {
    fprintf(_coverage_fout, "2895\n");
    fflush(_coverage_fout);
    ___coverage_array[2895] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  err = (timelib_error_container *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2896] == 0) {
    {
    fprintf(_coverage_fout, "2896\n");
    fflush(_coverage_fout);
    ___coverage_array[2896] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  type = 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2897] == 0) {
    {
    fprintf(_coverage_fout, "2897\n");
    fflush(_coverage_fout);
    ___coverage_array[2897] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2843] == 0) {
      {
      fprintf(_coverage_fout, "2843\n");
      fflush(_coverage_fout);
      ___coverage_array[2843] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_dtor(dateobj->time);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2844] == 0) {
      {
      fprintf(_coverage_fout, "2844\n");
      fflush(_coverage_fout);
      ___coverage_array[2844] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2898] == 0) {
    {
    fprintf(_coverage_fout, "2898\n");
    fflush(_coverage_fout);
    ___coverage_array[2898] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (format) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2852] == 0) {
      {
      fprintf(_coverage_fout, "2852\n");
      fflush(_coverage_fout);
      ___coverage_array[2852] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (php_date_global_timezone_db) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2845] == 0) {
        {
        fprintf(_coverage_fout, "2845\n");
        fflush(_coverage_fout);
        ___coverage_array[2845] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = (timelib_tzdb const   *)php_date_global_timezone_db;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2846] == 0) {
        {
        fprintf(_coverage_fout, "2846\n");
        fflush(_coverage_fout);
        ___coverage_array[2846] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = timelib_builtin_db();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2847] == 0) {
        {
        fprintf(_coverage_fout, "2847\n");
        fflush(_coverage_fout);
        ___coverage_array[2847] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = tmp;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2853] == 0) {
      {
      fprintf(_coverage_fout, "2853\n");
      fflush(_coverage_fout);
      ___coverage_array[2853] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (time_str_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2848] == 0) {
        {
        fprintf(_coverage_fout, "2848\n");
        fflush(_coverage_fout);
        ___coverage_array[2848] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = time_str_len;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2849] == 0) {
        {
        fprintf(_coverage_fout, "2849\n");
        fflush(_coverage_fout);
        ___coverage_array[2849] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = 0;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2854] == 0) {
      {
      fprintf(_coverage_fout, "2854\n");
      fflush(_coverage_fout);
      ___coverage_array[2854] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (time_str_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2850] == 0) {
        {
        fprintf(_coverage_fout, "2850\n");
        fflush(_coverage_fout);
        ___coverage_array[2850] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = (char const   *)time_str;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2851] == 0) {
        {
        fprintf(_coverage_fout, "2851\n");
        fflush(_coverage_fout);
        ___coverage_array[2851] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = "";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2855] == 0) {
      {
      fprintf(_coverage_fout, "2855\n");
      fflush(_coverage_fout);
      ___coverage_array[2855] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    dateobj->time = timelib_parse_from_format(format, (char *)tmp___2, tmp___1,
                                              & err, tmp___0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2863] == 0) {
      {
      fprintf(_coverage_fout, "2863\n");
      fflush(_coverage_fout);
      ___coverage_array[2863] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (php_date_global_timezone_db) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2856] == 0) {
        {
        fprintf(_coverage_fout, "2856\n");
        fflush(_coverage_fout);
        ___coverage_array[2856] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = (timelib_tzdb const   *)php_date_global_timezone_db;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2857] == 0) {
        {
        fprintf(_coverage_fout, "2857\n");
        fflush(_coverage_fout);
        ___coverage_array[2857] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___3 = timelib_builtin_db();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2858] == 0) {
        {
        fprintf(_coverage_fout, "2858\n");
        fflush(_coverage_fout);
        ___coverage_array[2858] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = tmp___3;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2864] == 0) {
      {
      fprintf(_coverage_fout, "2864\n");
      fflush(_coverage_fout);
      ___coverage_array[2864] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (time_str_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2859] == 0) {
        {
        fprintf(_coverage_fout, "2859\n");
        fflush(_coverage_fout);
        ___coverage_array[2859] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = (unsigned int )time_str_len;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2860] == 0) {
        {
        fprintf(_coverage_fout, "2860\n");
        fflush(_coverage_fout);
        ___coverage_array[2860] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = sizeof("now") - 1U;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2865] == 0) {
      {
      fprintf(_coverage_fout, "2865\n");
      fflush(_coverage_fout);
      ___coverage_array[2865] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (time_str_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2861] == 0) {
        {
        fprintf(_coverage_fout, "2861\n");
        fflush(_coverage_fout);
        ___coverage_array[2861] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = (char const   *)time_str;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2862] == 0) {
        {
        fprintf(_coverage_fout, "2862\n");
        fflush(_coverage_fout);
        ___coverage_array[2862] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = "now";
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2866] == 0) {
      {
      fprintf(_coverage_fout, "2866\n");
      fflush(_coverage_fout);
      ___coverage_array[2866] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    dateobj->time = timelib_strtotime((char *)tmp___6, (int )tmp___5, & err,
                                      tmp___4);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2899] == 0) {
    {
    fprintf(_coverage_fout, "2899\n");
    fflush(_coverage_fout);
    ___coverage_array[2899] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  update_errors_warnings(err);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2900] == 0) {
    {
    fprintf(_coverage_fout, "2900\n");
    fflush(_coverage_fout);
    ___coverage_array[2900] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ctor) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2871] == 0) {
      {
      fprintf(_coverage_fout, "2871\n");
      fflush(_coverage_fout);
      ___coverage_array[2871] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (err) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2869] == 0) {
        {
        fprintf(_coverage_fout, "2869\n");
        fflush(_coverage_fout);
        ___coverage_array[2869] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (err->error_count) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2867] == 0) {
          {
          fprintf(_coverage_fout, "2867\n");
          fflush(_coverage_fout);
          ___coverage_array[2867] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Failed to parse time string (%s) at position %d (%c): %s",
                          time_str, (err->error_messages + 0)->position,
                          (err->error_messages + 0)->character,
                          (err->error_messages + 0)->message);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2868] == 0) {
          {
          fprintf(_coverage_fout, "2868\n");
          fflush(_coverage_fout);
          ___coverage_array[2868] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2870] == 0) {
        {
        fprintf(_coverage_fout, "2870\n");
        fflush(_coverage_fout);
        ___coverage_array[2870] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2872] == 0) {
      {
      fprintf(_coverage_fout, "2872\n");
      fflush(_coverage_fout);
      ___coverage_array[2872] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2901] == 0) {
    {
    fprintf(_coverage_fout, "2901\n");
    fflush(_coverage_fout);
    ___coverage_array[2901] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (err) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2875] == 0) {
      {
      fprintf(_coverage_fout, "2875\n");
      fflush(_coverage_fout);
      ___coverage_array[2875] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (err->error_count) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2873] == 0) {
        {
        fprintf(_coverage_fout, "2873\n");
        fflush(_coverage_fout);
        ___coverage_array[2873] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return ((int __attribute__((__visibility__("default")))  )0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2874] == 0) {
        {
        fprintf(_coverage_fout, "2874\n");
        fflush(_coverage_fout);
        ___coverage_array[2874] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2876] == 0) {
      {
      fprintf(_coverage_fout, "2876\n");
      fflush(_coverage_fout);
      ___coverage_array[2876] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2902] == 0) {
    {
    fprintf(_coverage_fout, "2902\n");
    fflush(_coverage_fout);
    ___coverage_array[2902] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (timezone_object) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2883] == 0) {
      {
      fprintf(_coverage_fout, "2883\n");
      fflush(_coverage_fout);
      ___coverage_array[2883] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = zend_object_store_get_object((zval const   *)timezone_object);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2884] == 0) {
      {
      fprintf(_coverage_fout, "2884\n");
      fflush(_coverage_fout);
      ___coverage_array[2884] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzobj = (php_timezone_obj *)tmp___7;
    switch (tzobj->type) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2877] == 0) {
      {
      fprintf(_coverage_fout, "2877\n");
      fflush(_coverage_fout);
      ___coverage_array[2877] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 3: 
    tzi = tzobj->tzi.tz;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2878] == 0) {
      {
      fprintf(_coverage_fout, "2878\n");
      fflush(_coverage_fout);
      ___coverage_array[2878] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 1: 
    new_offset = tzobj->tzi.utc_offset;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2879] == 0) {
      {
      fprintf(_coverage_fout, "2879\n");
      fflush(_coverage_fout);
      ___coverage_array[2879] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 2: 
    new_offset = tzobj->tzi.z.utc_offset;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2880] == 0) {
      {
      fprintf(_coverage_fout, "2880\n");
      fflush(_coverage_fout);
      ___coverage_array[2880] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    new_dst = tzobj->tzi.z.dst;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2881] == 0) {
      {
      fprintf(_coverage_fout, "2881\n");
      fflush(_coverage_fout);
      ___coverage_array[2881] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___13 = __strdup((char const   *)tzobj->tzi.z.abbr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2882] == 0) {
      {
      fprintf(_coverage_fout, "2882\n");
      fflush(_coverage_fout);
      ___coverage_array[2882] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    new_abbr = tmp___13;
    break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2885] == 0) {
      {
      fprintf(_coverage_fout, "2885\n");
      fflush(_coverage_fout);
      ___coverage_array[2885] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    type = tzobj->type;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2889] == 0) {
      {
      fprintf(_coverage_fout, "2889\n");
      fflush(_coverage_fout);
      ___coverage_array[2889] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((dateobj->time)->tz_info) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2886] == 0) {
        {
        fprintf(_coverage_fout, "2886\n");
        fflush(_coverage_fout);
        ___coverage_array[2886] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tzi = (dateobj->time)->tz_info;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2887] == 0) {
        {
        fprintf(_coverage_fout, "2887\n");
        fflush(_coverage_fout);
        ___coverage_array[2887] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___14 = get_timezone_info();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2888] == 0) {
        {
        fprintf(_coverage_fout, "2888\n");
        fflush(_coverage_fout);
        ___coverage_array[2888] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tzi = (timelib_tzinfo *)tmp___14;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2903] == 0) {
    {
    fprintf(_coverage_fout, "2903\n");
    fflush(_coverage_fout);
    ___coverage_array[2903] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  now = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2904] == 0) {
    {
    fprintf(_coverage_fout, "2904\n");
    fflush(_coverage_fout);
    ___coverage_array[2904] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  now->zone_type = (unsigned int )type;
  switch (type) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2890] == 0) {
    {
    fprintf(_coverage_fout, "2890\n");
    fflush(_coverage_fout);
    ___coverage_array[2890] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  now->tz_info = tzi;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2891] == 0) {
    {
    fprintf(_coverage_fout, "2891\n");
    fflush(_coverage_fout);
    ___coverage_array[2891] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  now->z = (int )new_offset;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2892] == 0) {
    {
    fprintf(_coverage_fout, "2892\n");
    fflush(_coverage_fout);
    ___coverage_array[2892] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  now->z = (int )new_offset;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2893] == 0) {
    {
    fprintf(_coverage_fout, "2893\n");
    fflush(_coverage_fout);
    ___coverage_array[2893] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  now->dst = new_dst;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2894] == 0) {
    {
    fprintf(_coverage_fout, "2894\n");
    fflush(_coverage_fout);
    ___coverage_array[2894] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  now->tz_abbr = new_abbr;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2905] == 0) {
    {
    fprintf(_coverage_fout, "2905\n");
    fflush(_coverage_fout);
    ___coverage_array[2905] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___15 = time((time_t *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2906] == 0) {
    {
    fprintf(_coverage_fout, "2906\n");
    fflush(_coverage_fout);
    ___coverage_array[2906] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(now, (long long )tmp___15);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2907] == 0) {
    {
    fprintf(_coverage_fout, "2907\n");
    fflush(_coverage_fout);
    ___coverage_array[2907] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_fill_holes(dateobj->time, now, 0x02);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2908] == 0) {
    {
    fprintf(_coverage_fout, "2908\n");
    fflush(_coverage_fout);
    ___coverage_array[2908] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, tzi);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2909] == 0) {
    {
    fprintf(_coverage_fout, "2909\n");
    fflush(_coverage_fout);
    ___coverage_array[2909] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2910] == 0) {
    {
    fprintf(_coverage_fout, "2910\n");
    fflush(_coverage_fout);
    ___coverage_array[2910] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(now);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2911] == 0) {
    {
    fprintf(_coverage_fout, "2911\n");
    fflush(_coverage_fout);
    ___coverage_array[2911] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return ((int __attribute__((__visibility__("default")))  )1);
}
}
void zif_date_create(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) 
{ zval *timezone_object ;
  char *time_str ;
  int time_str_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2924] == 0) {
    {
    fprintf(_coverage_fout, "2924\n");
    fflush(_coverage_fout);
    ___coverage_array[2924] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timezone_object = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2925] == 0) {
    {
    fprintf(_coverage_fout, "2925\n");
    fflush(_coverage_fout);
    ___coverage_array[2925] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2926] == 0) {
    {
    fprintf(_coverage_fout, "2926\n");
    fflush(_coverage_fout);
    ___coverage_array[2926] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2927] == 0) {
    {
    fprintf(_coverage_fout, "2927\n");
    fflush(_coverage_fout);
    ___coverage_array[2927] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "|sO!", & time_str, & time_str_len,
                              & timezone_object, date_ce_timezone);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2928] == 0) {
    {
    fprintf(_coverage_fout, "2928\n");
    fflush(_coverage_fout);
    ___coverage_array[2928] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2915] == 0) {
      {
      fprintf(_coverage_fout, "2915\n");
      fflush(_coverage_fout);
      ___coverage_array[2915] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2912] == 0) {
        {
        fprintf(_coverage_fout, "2912\n");
        fflush(_coverage_fout);
        ___coverage_array[2912] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2913] == 0) {
        {
        fprintf(_coverage_fout, "2913\n");
        fflush(_coverage_fout);
        ___coverage_array[2913] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2914] == 0) {
        {
        fprintf(_coverage_fout, "2914\n");
        fflush(_coverage_fout);
        ___coverage_array[2914] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2916] == 0) {
      {
      fprintf(_coverage_fout, "2916\n");
      fflush(_coverage_fout);
      ___coverage_array[2916] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2917] == 0) {
      {
      fprintf(_coverage_fout, "2917\n");
      fflush(_coverage_fout);
      ___coverage_array[2917] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2929] == 0) {
    {
    fprintf(_coverage_fout, "2929\n");
    fflush(_coverage_fout);
    ___coverage_array[2929] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_instantiate(date_ce_date, return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2930] == 0) {
    {
    fprintf(_coverage_fout, "2930\n");
    fflush(_coverage_fout);
    ___coverage_array[2930] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2931] == 0) {
    {
    fprintf(_coverage_fout, "2931\n");
    fflush(_coverage_fout);
    ___coverage_array[2931] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = php_date_initialize((php_date_obj *)tmp___0, time_str, time_str_len,
                                (char *)((void *)0), timezone_object, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2932] == 0) {
    {
    fprintf(_coverage_fout, "2932\n");
    fflush(_coverage_fout);
    ___coverage_array[2932] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2918] == 0) {
      {
      fprintf(_coverage_fout, "2918\n");
      fflush(_coverage_fout);
      ___coverage_array[2918] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2922] == 0) {
      {
      fprintf(_coverage_fout, "2922\n");
      fflush(_coverage_fout);
      ___coverage_array[2922] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2919] == 0) {
        {
        fprintf(_coverage_fout, "2919\n");
        fflush(_coverage_fout);
        ___coverage_array[2919] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2920] == 0) {
        {
        fprintf(_coverage_fout, "2920\n");
        fflush(_coverage_fout);
        ___coverage_array[2920] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2921] == 0) {
        {
        fprintf(_coverage_fout, "2921\n");
        fflush(_coverage_fout);
        ___coverage_array[2921] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2923] == 0) {
      {
      fprintf(_coverage_fout, "2923\n");
      fflush(_coverage_fout);
      ___coverage_array[2923] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2933] == 0) {
    {
    fprintf(_coverage_fout, "2933\n");
    fflush(_coverage_fout);
    ___coverage_array[2933] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_create_from_format(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) 
{ zval *timezone_object ;
  char *time_str ;
  char *format_str ;
  int time_str_len ;
  int format_str_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2946] == 0) {
    {
    fprintf(_coverage_fout, "2946\n");
    fflush(_coverage_fout);
    ___coverage_array[2946] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timezone_object = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2947] == 0) {
    {
    fprintf(_coverage_fout, "2947\n");
    fflush(_coverage_fout);
    ___coverage_array[2947] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2948] == 0) {
    {
    fprintf(_coverage_fout, "2948\n");
    fflush(_coverage_fout);
    ___coverage_array[2948] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  format_str = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2949] == 0) {
    {
    fprintf(_coverage_fout, "2949\n");
    fflush(_coverage_fout);
    ___coverage_array[2949] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2950] == 0) {
    {
    fprintf(_coverage_fout, "2950\n");
    fflush(_coverage_fout);
    ___coverage_array[2950] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  format_str_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2951] == 0) {
    {
    fprintf(_coverage_fout, "2951\n");
    fflush(_coverage_fout);
    ___coverage_array[2951] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "ss|O", & format_str, & format_str_len,
                              & time_str, & time_str_len, & timezone_object,
                              date_ce_timezone);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2952] == 0) {
    {
    fprintf(_coverage_fout, "2952\n");
    fflush(_coverage_fout);
    ___coverage_array[2952] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2937] == 0) {
      {
      fprintf(_coverage_fout, "2937\n");
      fflush(_coverage_fout);
      ___coverage_array[2937] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2934] == 0) {
        {
        fprintf(_coverage_fout, "2934\n");
        fflush(_coverage_fout);
        ___coverage_array[2934] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2935] == 0) {
        {
        fprintf(_coverage_fout, "2935\n");
        fflush(_coverage_fout);
        ___coverage_array[2935] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2936] == 0) {
        {
        fprintf(_coverage_fout, "2936\n");
        fflush(_coverage_fout);
        ___coverage_array[2936] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2938] == 0) {
      {
      fprintf(_coverage_fout, "2938\n");
      fflush(_coverage_fout);
      ___coverage_array[2938] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2939] == 0) {
      {
      fprintf(_coverage_fout, "2939\n");
      fflush(_coverage_fout);
      ___coverage_array[2939] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2953] == 0) {
    {
    fprintf(_coverage_fout, "2953\n");
    fflush(_coverage_fout);
    ___coverage_array[2953] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_instantiate(date_ce_date, return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2954] == 0) {
    {
    fprintf(_coverage_fout, "2954\n");
    fflush(_coverage_fout);
    ___coverage_array[2954] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2955] == 0) {
    {
    fprintf(_coverage_fout, "2955\n");
    fflush(_coverage_fout);
    ___coverage_array[2955] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = php_date_initialize((php_date_obj *)tmp___0, time_str, time_str_len,
                                format_str, timezone_object, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2956] == 0) {
    {
    fprintf(_coverage_fout, "2956\n");
    fflush(_coverage_fout);
    ___coverage_array[2956] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2940] == 0) {
      {
      fprintf(_coverage_fout, "2940\n");
      fflush(_coverage_fout);
      ___coverage_array[2940] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2944] == 0) {
      {
      fprintf(_coverage_fout, "2944\n");
      fflush(_coverage_fout);
      ___coverage_array[2944] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2941] == 0) {
        {
        fprintf(_coverage_fout, "2941\n");
        fflush(_coverage_fout);
        ___coverage_array[2941] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2942] == 0) {
        {
        fprintf(_coverage_fout, "2942\n");
        fflush(_coverage_fout);
        ___coverage_array[2942] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2943] == 0) {
        {
        fprintf(_coverage_fout, "2943\n");
        fflush(_coverage_fout);
        ___coverage_array[2943] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2945] == 0) {
      {
      fprintf(_coverage_fout, "2945\n");
      fflush(_coverage_fout);
      ___coverage_array[2945] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2957] == 0) {
    {
    fprintf(_coverage_fout, "2957\n");
    fflush(_coverage_fout);
    ___coverage_array[2957] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zim_DateTime___construct(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ zval *timezone_object ;
  char *time_str ;
  int time_str_len ;
  zend_error_handling error_handling ;
  void __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2961] == 0) {
    {
    fprintf(_coverage_fout, "2961\n");
    fflush(_coverage_fout);
    ___coverage_array[2961] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timezone_object = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2962] == 0) {
    {
    fprintf(_coverage_fout, "2962\n");
    fflush(_coverage_fout);
    ___coverage_array[2962] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2963] == 0) {
    {
    fprintf(_coverage_fout, "2963\n");
    fflush(_coverage_fout);
    ___coverage_array[2963] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2964] == 0) {
    {
    fprintf(_coverage_fout, "2964\n");
    fflush(_coverage_fout);
    ___coverage_array[2964] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_replace_error_handling((enum __anonenum_zend_error_handling_t_47 )2,
                              (zend_class_entry *)((void *)0), & error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2965] == 0) {
    {
    fprintf(_coverage_fout, "2965\n");
    fflush(_coverage_fout);
    ___coverage_array[2965] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_parse_parameters(ht, "|sO!", & time_str, & time_str_len,
                                  & timezone_object, date_ce_timezone);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2966] == 0) {
    {
    fprintf(_coverage_fout, "2966\n");
    fflush(_coverage_fout);
    ___coverage_array[2966] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (0 == (int )tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2958] == 0) {
      {
      fprintf(_coverage_fout, "2958\n");
      fflush(_coverage_fout);
      ___coverage_array[2958] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = zend_object_store_get_object((zval const   *)this_ptr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2959] == 0) {
      {
      fprintf(_coverage_fout, "2959\n");
      fflush(_coverage_fout);
      ___coverage_array[2959] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_date_initialize((php_date_obj *)tmp, time_str, time_str_len,
                        (char *)((void *)0), timezone_object, 1);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[2960] == 0) {
      {
      fprintf(_coverage_fout, "2960\n");
      fflush(_coverage_fout);
      ___coverage_array[2960] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2967] == 0) {
    {
    fprintf(_coverage_fout, "2967\n");
    fflush(_coverage_fout);
    ___coverage_array[2967] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_restore_error_handling(& error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[2968] == 0) {
    {
    fprintf(_coverage_fout, "2968\n");
    fflush(_coverage_fout);
    ___coverage_array[2968] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int php_date_initialize_from_hash(zval **return_value ,
                                         php_date_obj **dateobj ,
                                         HashTable *myht ) 
{ zval **z_date ;
  zval **z_timezone ;
  zval **z_timezone_type ;
  zval *tmp_obj ;
  timelib_tzinfo *tzi ;
  php_timezone_obj *tzobj ;
  char *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;
  timelib_tzdb const   *tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  zval __attribute__((__visibility__("default")))  *tmp___4 ;
  void __attribute__((__visibility__("default")))  *tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;
  int __attribute__((__visibility__("default")))  tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3011] == 0) {
    {
    fprintf(_coverage_fout, "3011\n");
    fflush(_coverage_fout);
    ___coverage_array[3011] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  z_date = (zval **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3012] == 0) {
    {
    fprintf(_coverage_fout, "3012\n");
    fflush(_coverage_fout);
    ___coverage_array[3012] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  z_timezone = (zval **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3013] == 0) {
    {
    fprintf(_coverage_fout, "3013\n");
    fflush(_coverage_fout);
    ___coverage_array[3013] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  z_timezone_type = (zval **)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3014] == 0) {
    {
    fprintf(_coverage_fout, "3014\n");
    fflush(_coverage_fout);
    ___coverage_array[3014] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp_obj = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3015] == 0) {
    {
    fprintf(_coverage_fout, "3015\n");
    fflush(_coverage_fout);
    ___coverage_array[3015] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___8 = zend_hash_find((HashTable const   *)myht, "date", 5U,
                           (void **)(& z_date));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3016] == 0) {
    {
    fprintf(_coverage_fout, "3016\n");
    fflush(_coverage_fout);
    ___coverage_array[3016] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___8 == (int __attribute__((__visibility__("default")))  )0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3007] == 0) {
      {
      fprintf(_coverage_fout, "3007\n");
      fflush(_coverage_fout);
      ___coverage_array[3007] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )(*z_date)->type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2969] == 0) {
        {
        fprintf(_coverage_fout, "2969\n");
        fflush(_coverage_fout);
        ___coverage_array[2969] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(*z_date);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[2970] == 0) {
        {
        fprintf(_coverage_fout, "2970\n");
        fflush(_coverage_fout);
        ___coverage_array[2970] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3008] == 0) {
      {
      fprintf(_coverage_fout, "3008\n");
      fflush(_coverage_fout);
      ___coverage_array[3008] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = zend_hash_find((HashTable const   *)myht, "timezone_type", 14U,
                             (void **)(& z_timezone_type));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3009] == 0) {
      {
      fprintf(_coverage_fout, "3009\n");
      fflush(_coverage_fout);
      ___coverage_array[3009] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___7 == (int __attribute__((__visibility__("default")))  )0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3003] == 0) {
        {
        fprintf(_coverage_fout, "3003\n");
        fflush(_coverage_fout);
        ___coverage_array[3003] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      convert_to_long(*z_timezone_type);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3004] == 0) {
        {
        fprintf(_coverage_fout, "3004\n");
        fflush(_coverage_fout);
        ___coverage_array[3004] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___6 = zend_hash_find((HashTable const   *)myht, "timezone", 9U,
                               (void **)(& z_timezone));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3005] == 0) {
        {
        fprintf(_coverage_fout, "3005\n");
        fflush(_coverage_fout);
        ___coverage_array[3005] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___6 == (int __attribute__((__visibility__("default")))  )0) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3001] == 0) {
          {
          fprintf(_coverage_fout, "3001\n");
          fflush(_coverage_fout);
          ___coverage_array[3001] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((int )(*z_timezone)->type != 6) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2971] == 0) {
            {
            fprintf(_coverage_fout, "2971\n");
            fflush(_coverage_fout);
            ___coverage_array[2971] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _convert_to_string(*z_timezone);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2972] == 0) {
            {
            fprintf(_coverage_fout, "2972\n");
            fflush(_coverage_fout);
            ___coverage_array[2972] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        switch ((int )(*z_timezone_type)->value.lval) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2981] == 0) {
          {
          fprintf(_coverage_fout, "2981\n");
          fflush(_coverage_fout);
          ___coverage_array[2981] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        case 1: 
        case 2: 
        tmp___0 = _emalloc((unsigned int )(((*z_date)->value.str.len + (*z_timezone)->value.str.len) + 2));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2982] == 0) {
          {
          fprintf(_coverage_fout, "2982\n");
          fflush(_coverage_fout);
          ___coverage_array[2982] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp = (char *)tmp___0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2983] == 0) {
          {
          fprintf(_coverage_fout, "2983\n");
          fflush(_coverage_fout);
          ___coverage_array[2983] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ap_php_snprintf(tmp,
                        (unsigned int )(((*z_date)->value.str.len + (*z_timezone)->value.str.len) + 2),
                        "%s %s", (*z_date)->value.str.val,
                        (*z_timezone)->value.str.val);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2984] == 0) {
          {
          fprintf(_coverage_fout, "2984\n");
          fflush(_coverage_fout);
          ___coverage_array[2984] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_date_initialize(*dateobj, tmp,
                            ((*z_date)->value.str.len + (*z_timezone)->value.str.len) + 1,
                            (char *)((void *)0), (zval *)((void *)0), 0);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2985] == 0) {
          {
          fprintf(_coverage_fout, "2985\n");
          fflush(_coverage_fout);
          ___coverage_array[2985] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _efree((void *)tmp);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2986] == 0) {
          {
          fprintf(_coverage_fout, "2986\n");
          fflush(_coverage_fout);
          ___coverage_array[2986] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (1);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2987] == 0) {
          {
          fprintf(_coverage_fout, "2987\n");
          fflush(_coverage_fout);
          ___coverage_array[2987] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        case 3: 
        if ((int )(*z_timezone)->type != 6) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2973] == 0) {
            {
            fprintf(_coverage_fout, "2973\n");
            fflush(_coverage_fout);
            ___coverage_array[2973] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _convert_to_string(*z_timezone);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2974] == 0) {
            {
            fprintf(_coverage_fout, "2974\n");
            fflush(_coverage_fout);
            ___coverage_array[2974] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2988] == 0) {
          {
          fprintf(_coverage_fout, "2988\n");
          fflush(_coverage_fout);
          ___coverage_array[2988] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (php_date_global_timezone_db) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2975] == 0) {
            {
            fprintf(_coverage_fout, "2975\n");
            fflush(_coverage_fout);
            ___coverage_array[2975] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___2 = (timelib_tzdb const   *)php_date_global_timezone_db;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2976] == 0) {
            {
            fprintf(_coverage_fout, "2976\n");
            fflush(_coverage_fout);
            ___coverage_array[2976] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___1 = timelib_builtin_db();
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2977] == 0) {
            {
            fprintf(_coverage_fout, "2977\n");
            fflush(_coverage_fout);
            ___coverage_array[2977] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___2 = tmp___1;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2989] == 0) {
          {
          fprintf(_coverage_fout, "2989\n");
          fflush(_coverage_fout);
          ___coverage_array[2989] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tzi = php_date_parse_tzfile((*z_timezone)->value.str.val, tmp___2);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2990] == 0) {
          {
          fprintf(_coverage_fout, "2990\n");
          fflush(_coverage_fout);
          ___coverage_array[2990] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2978] == 0) {
            {
            fprintf(_coverage_fout, "2978\n");
            fflush(_coverage_fout);
            ___coverage_array[2978] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___3 = _emalloc(sizeof(zval_gc_info ));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2979] == 0) {
            {
            fprintf(_coverage_fout, "2979\n");
            fflush(_coverage_fout);
            ___coverage_array[2979] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp_obj = (zval *)tmp___3;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[2980] == 0) {
            {
            fprintf(_coverage_fout, "2980\n");
            fflush(_coverage_fout);
            ___coverage_array[2980] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          ((zval_gc_info *)tmp_obj)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2991] == 0) {
          {
          fprintf(_coverage_fout, "2991\n");
          fflush(_coverage_fout);
          ___coverage_array[2991] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        *tmp_obj = (struct _zval_struct )zval_used_for_init;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2992] == 0) {
          {
          fprintf(_coverage_fout, "2992\n");
          fflush(_coverage_fout);
          ___coverage_array[2992] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___4 = php_date_instantiate(date_ce_timezone, tmp_obj);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2993] == 0) {
          {
          fprintf(_coverage_fout, "2993\n");
          fflush(_coverage_fout);
          ___coverage_array[2993] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = zend_object_store_get_object((zval const   *)tmp___4);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2994] == 0) {
          {
          fprintf(_coverage_fout, "2994\n");
          fflush(_coverage_fout);
          ___coverage_array[2994] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tzobj = (php_timezone_obj *)tmp___5;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2995] == 0) {
          {
          fprintf(_coverage_fout, "2995\n");
          fflush(_coverage_fout);
          ___coverage_array[2995] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tzobj->type = 3;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2996] == 0) {
          {
          fprintf(_coverage_fout, "2996\n");
          fflush(_coverage_fout);
          ___coverage_array[2996] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tzobj->tzi.tz = tzi;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2997] == 0) {
          {
          fprintf(_coverage_fout, "2997\n");
          fflush(_coverage_fout);
          ___coverage_array[2997] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tzobj->initialized = 1;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2998] == 0) {
          {
          fprintf(_coverage_fout, "2998\n");
          fflush(_coverage_fout);
          ___coverage_array[2998] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_date_initialize(*dateobj, (*z_date)->value.str.val,
                            (*z_date)->value.str.len, (char *)((void *)0),
                            tmp_obj, 0);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[2999] == 0) {
          {
          fprintf(_coverage_fout, "2999\n");
          fflush(_coverage_fout);
          ___coverage_array[2999] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_ptr_dtor(& tmp_obj);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3000] == 0) {
          {
          fprintf(_coverage_fout, "3000\n");
          fflush(_coverage_fout);
          ___coverage_array[3000] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return (1);
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3002] == 0) {
          {
          fprintf(_coverage_fout, "3002\n");
          fflush(_coverage_fout);
          ___coverage_array[3002] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3006] == 0) {
        {
        fprintf(_coverage_fout, "3006\n");
        fflush(_coverage_fout);
        ___coverage_array[3006] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3010] == 0) {
      {
      fprintf(_coverage_fout, "3010\n");
      fflush(_coverage_fout);
      ___coverage_array[3010] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3017] == 0) {
    {
    fprintf(_coverage_fout, "3017\n");
    fflush(_coverage_fout);
    ___coverage_array[3017] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
void zim_DateTime___set_state(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ php_date_obj *dateobj ;
  zval *array ;
  HashTable *myht ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  HashTable *tmp___0 ;
  HashTable *tmp___1 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3030] == 0) {
    {
    fprintf(_coverage_fout, "3030\n");
    fflush(_coverage_fout);
    ___coverage_array[3030] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "a", & array);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3031] == 0) {
    {
    fprintf(_coverage_fout, "3031\n");
    fflush(_coverage_fout);
    ___coverage_array[3031] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3021] == 0) {
      {
      fprintf(_coverage_fout, "3021\n");
      fflush(_coverage_fout);
      ___coverage_array[3021] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3018] == 0) {
        {
        fprintf(_coverage_fout, "3018\n");
        fflush(_coverage_fout);
        ___coverage_array[3018] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3019] == 0) {
        {
        fprintf(_coverage_fout, "3019\n");
        fflush(_coverage_fout);
        ___coverage_array[3019] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3020] == 0) {
        {
        fprintf(_coverage_fout, "3020\n");
        fflush(_coverage_fout);
        ___coverage_array[3020] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3022] == 0) {
      {
      fprintf(_coverage_fout, "3022\n");
      fflush(_coverage_fout);
      ___coverage_array[3022] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3023] == 0) {
      {
      fprintf(_coverage_fout, "3023\n");
      fflush(_coverage_fout);
      ___coverage_array[3023] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3032] == 0) {
    {
    fprintf(_coverage_fout, "3032\n");
    fflush(_coverage_fout);
    ___coverage_array[3032] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )array->type == 4) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3024] == 0) {
      {
      fprintf(_coverage_fout, "3024\n");
      fflush(_coverage_fout);
      ___coverage_array[3024] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    myht = array->value.ht;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3028] == 0) {
      {
      fprintf(_coverage_fout, "3028\n");
      fflush(_coverage_fout);
      ___coverage_array[3028] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )array->type == 5) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3025] == 0) {
        {
        fprintf(_coverage_fout, "3025\n");
        fflush(_coverage_fout);
        ___coverage_array[3025] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = (*((array->value.obj.handlers)->get_properties))(array);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3026] == 0) {
        {
        fprintf(_coverage_fout, "3026\n");
        fflush(_coverage_fout);
        ___coverage_array[3026] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = tmp___0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3027] == 0) {
        {
        fprintf(_coverage_fout, "3027\n");
        fflush(_coverage_fout);
        ___coverage_array[3027] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = (HashTable *)((void *)0);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3029] == 0) {
      {
      fprintf(_coverage_fout, "3029\n");
      fflush(_coverage_fout);
      ___coverage_array[3029] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    myht = tmp___1;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3033] == 0) {
    {
    fprintf(_coverage_fout, "3033\n");
    fflush(_coverage_fout);
    ___coverage_array[3033] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_instantiate(date_ce_date, return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3034] == 0) {
    {
    fprintf(_coverage_fout, "3034\n");
    fflush(_coverage_fout);
    ___coverage_array[3034] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zend_object_store_get_object((zval const   *)return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3035] == 0) {
    {
    fprintf(_coverage_fout, "3035\n");
    fflush(_coverage_fout);
    ___coverage_array[3035] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3036] == 0) {
    {
    fprintf(_coverage_fout, "3036\n");
    fflush(_coverage_fout);
    ___coverage_array[3036] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_initialize_from_hash(& return_value, & dateobj, myht);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3037] == 0) {
    {
    fprintf(_coverage_fout, "3037\n");
    fflush(_coverage_fout);
    ___coverage_array[3037] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zim_DateTime___wakeup(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  HashTable *myht ;
  void __attribute__((__visibility__("default")))  *tmp ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3038] == 0) {
    {
    fprintf(_coverage_fout, "3038\n");
    fflush(_coverage_fout);
    ___coverage_array[3038] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  object = this_ptr;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3039] == 0) {
    {
    fprintf(_coverage_fout, "3039\n");
    fflush(_coverage_fout);
    ___coverage_array[3039] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3040] == 0) {
    {
    fprintf(_coverage_fout, "3040\n");
    fflush(_coverage_fout);
    ___coverage_array[3040] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3041] == 0) {
    {
    fprintf(_coverage_fout, "3041\n");
    fflush(_coverage_fout);
    ___coverage_array[3041] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  myht = (*((object->value.obj.handlers)->get_properties))(object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3042] == 0) {
    {
    fprintf(_coverage_fout, "3042\n");
    fflush(_coverage_fout);
    ___coverage_array[3042] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_initialize_from_hash(& return_value, & dateobj, myht);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3043] == 0) {
    {
    fprintf(_coverage_fout, "3043\n");
    fflush(_coverage_fout);
    ___coverage_array[3043] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void zval_from_error_container(zval *z , timelib_error_container *error ) 
{ int i ;
  zval *element ;
  size_t tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  size_t tmp___1 ;
  size_t tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  size_t tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3058] == 0) {
    {
    fprintf(_coverage_fout, "3058\n");
    fflush(_coverage_fout);
    ___coverage_array[3058] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = strlen("warning_count");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3059] == 0) {
    {
    fprintf(_coverage_fout, "3059\n");
    fflush(_coverage_fout);
    ___coverage_array[3059] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(z, "warning_count", tmp + 1U, (long )error->warning_count);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3060] == 0) {
    {
    fprintf(_coverage_fout, "3060\n");
    fflush(_coverage_fout);
    ___coverage_array[3060] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3044] == 0) {
      {
      fprintf(_coverage_fout, "3044\n");
      fflush(_coverage_fout);
      ___coverage_array[3044] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3045] == 0) {
      {
      fprintf(_coverage_fout, "3045\n");
      fflush(_coverage_fout);
      ___coverage_array[3045] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element = (zval *)tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3046] == 0) {
      {
      fprintf(_coverage_fout, "3046\n");
      fflush(_coverage_fout);
      ___coverage_array[3046] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3061] == 0) {
    {
    fprintf(_coverage_fout, "3061\n");
    fflush(_coverage_fout);
    ___coverage_array[3061] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  element->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3062] == 0) {
    {
    fprintf(_coverage_fout, "3062\n");
    fflush(_coverage_fout);
    ___coverage_array[3062] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  element->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3063] == 0) {
    {
    fprintf(_coverage_fout, "3063\n");
    fflush(_coverage_fout);
    ___coverage_array[3063] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(element, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3064] == 0) {
    {
    fprintf(_coverage_fout, "3064\n");
    fflush(_coverage_fout);
    ___coverage_array[3064] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  i = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3065] == 0) {
    {
    fprintf(_coverage_fout, "3065\n");
    fflush(_coverage_fout);
    ___coverage_array[3065] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3048] == 0) {
      {
      fprintf(_coverage_fout, "3048\n");
      fflush(_coverage_fout);
      ___coverage_array[3048] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (i < error->warning_count) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3047] == 0) {
        {
        fprintf(_coverage_fout, "3047\n");
        fflush(_coverage_fout);
        ___coverage_array[3047] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3049] == 0) {
      {
      fprintf(_coverage_fout, "3049\n");
      fflush(_coverage_fout);
      ___coverage_array[3049] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_index_string(element,
                     (unsigned long )(error->warning_messages + i)->position,
                     (char const   *)(error->warning_messages + i)->message, 1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3050] == 0) {
      {
      fprintf(_coverage_fout, "3050\n");
      fflush(_coverage_fout);
      ___coverage_array[3050] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3066] == 0) {
    {
    fprintf(_coverage_fout, "3066\n");
    fflush(_coverage_fout);
    ___coverage_array[3066] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = strlen("warnings");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3067] == 0) {
    {
    fprintf(_coverage_fout, "3067\n");
    fflush(_coverage_fout);
    ___coverage_array[3067] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_zval_ex(z, "warnings", tmp___1 + 1U, element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3068] == 0) {
    {
    fprintf(_coverage_fout, "3068\n");
    fflush(_coverage_fout);
    ___coverage_array[3068] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = strlen("error_count");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3069] == 0) {
    {
    fprintf(_coverage_fout, "3069\n");
    fflush(_coverage_fout);
    ___coverage_array[3069] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(z, "error_count", tmp___2 + 1U, (long )error->error_count);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3070] == 0) {
    {
    fprintf(_coverage_fout, "3070\n");
    fflush(_coverage_fout);
    ___coverage_array[3070] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3051] == 0) {
      {
      fprintf(_coverage_fout, "3051\n");
      fflush(_coverage_fout);
      ___coverage_array[3051] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3052] == 0) {
      {
      fprintf(_coverage_fout, "3052\n");
      fflush(_coverage_fout);
      ___coverage_array[3052] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element = (zval *)tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3053] == 0) {
      {
      fprintf(_coverage_fout, "3053\n");
      fflush(_coverage_fout);
      ___coverage_array[3053] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3071] == 0) {
    {
    fprintf(_coverage_fout, "3071\n");
    fflush(_coverage_fout);
    ___coverage_array[3071] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  element->refcount__gc = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3072] == 0) {
    {
    fprintf(_coverage_fout, "3072\n");
    fflush(_coverage_fout);
    ___coverage_array[3072] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  element->is_ref__gc = (unsigned char)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3073] == 0) {
    {
    fprintf(_coverage_fout, "3073\n");
    fflush(_coverage_fout);
    ___coverage_array[3073] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(element, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3074] == 0) {
    {
    fprintf(_coverage_fout, "3074\n");
    fflush(_coverage_fout);
    ___coverage_array[3074] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  i = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3075] == 0) {
    {
    fprintf(_coverage_fout, "3075\n");
    fflush(_coverage_fout);
    ___coverage_array[3075] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3055] == 0) {
      {
      fprintf(_coverage_fout, "3055\n");
      fflush(_coverage_fout);
      ___coverage_array[3055] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (i < error->error_count) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3054] == 0) {
        {
        fprintf(_coverage_fout, "3054\n");
        fflush(_coverage_fout);
        ___coverage_array[3054] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3056] == 0) {
      {
      fprintf(_coverage_fout, "3056\n");
      fflush(_coverage_fout);
      ___coverage_array[3056] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_index_string(element,
                     (unsigned long )(error->error_messages + i)->position,
                     (char const   *)(error->error_messages + i)->message, 1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3057] == 0) {
      {
      fprintf(_coverage_fout, "3057\n");
      fflush(_coverage_fout);
      ___coverage_array[3057] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3076] == 0) {
    {
    fprintf(_coverage_fout, "3076\n");
    fflush(_coverage_fout);
    ___coverage_array[3076] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = strlen("errors");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3077] == 0) {
    {
    fprintf(_coverage_fout, "3077\n");
    fflush(_coverage_fout);
    ___coverage_array[3077] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_zval_ex(z, "errors", tmp___4 + 1U, element);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3078] == 0) {
    {
    fprintf(_coverage_fout, "3078\n");
    fflush(_coverage_fout);
    ___coverage_array[3078] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_get_last_errors(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ zval *__z ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3086] == 0) {
    {
    fprintf(_coverage_fout, "3086\n");
    fflush(_coverage_fout);
    ___coverage_array[3086] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.last_errors) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3079] == 0) {
      {
      fprintf(_coverage_fout, "3079\n");
      fflush(_coverage_fout);
      ___coverage_array[3079] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _array_init(return_value, 0U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3080] == 0) {
      {
      fprintf(_coverage_fout, "3080\n");
      fflush(_coverage_fout);
      ___coverage_array[3080] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zval_from_error_container(return_value, date_globals.last_errors);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3084] == 0) {
      {
      fprintf(_coverage_fout, "3084\n");
      fflush(_coverage_fout);
      ___coverage_array[3084] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3081] == 0) {
        {
        fprintf(_coverage_fout, "3081\n");
        fflush(_coverage_fout);
        ___coverage_array[3081] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3082] == 0) {
        {
        fprintf(_coverage_fout, "3082\n");
        fflush(_coverage_fout);
        ___coverage_array[3082] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3083] == 0) {
        {
        fprintf(_coverage_fout, "3083\n");
        fflush(_coverage_fout);
        ___coverage_array[3083] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3085] == 0) {
      {
      fprintf(_coverage_fout, "3085\n");
      fflush(_coverage_fout);
      ___coverage_array[3085] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3087] == 0) {
    {
    fprintf(_coverage_fout, "3087\n");
    fflush(_coverage_fout);
    ___coverage_array[3087] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void php_date_do_return_parsed_time(int ht , zval *return_value ,
                                    zval **return_value_ptr , zval *this_ptr ,
                                    int return_value_used ,
                                    timelib_time *parsed_time ,
                                    struct timelib_error_container *error ) 
{ zval *element ;
  size_t tmp ;
  size_t tmp___0 ;
  size_t tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  size_t tmp___4 ;
  size_t tmp___5 ;
  size_t tmp___6 ;
  size_t tmp___7 ;
  size_t tmp___8 ;
  size_t tmp___9 ;
  size_t tmp___10 ;
  size_t tmp___11 ;
  size_t tmp___12 ;
  size_t tmp___13 ;
  size_t tmp___14 ;
  size_t tmp___15 ;
  size_t tmp___16 ;
  size_t tmp___17 ;
  size_t tmp___18 ;
  size_t tmp___19 ;
  size_t tmp___20 ;
  size_t tmp___21 ;
  size_t tmp___22 ;
  size_t tmp___23 ;
  size_t tmp___24 ;
  void __attribute__((__visibility__("default")))  *tmp___25 ;
  size_t tmp___26 ;
  size_t tmp___27 ;
  size_t tmp___28 ;
  size_t tmp___29 ;
  size_t tmp___30 ;
  size_t tmp___31 ;
  size_t tmp___32 ;
  size_t tmp___33 ;
  char const   *tmp___34 ;
  size_t tmp___35 ;
  char const   *tmp___36 ;
  size_t tmp___37 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3188] == 0) {
    {
    fprintf(_coverage_fout, "3188\n");
    fflush(_coverage_fout);
    ___coverage_array[3188] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3189] == 0) {
    {
    fprintf(_coverage_fout, "3189\n");
    fflush(_coverage_fout);
    ___coverage_array[3189] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->y == -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3088] == 0) {
      {
      fprintf(_coverage_fout, "3088\n");
      fflush(_coverage_fout);
      ___coverage_array[3088] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = strlen("year");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3089] == 0) {
      {
      fprintf(_coverage_fout, "3089\n");
      fflush(_coverage_fout);
      ___coverage_array[3089] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "year", tmp + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3090] == 0) {
      {
      fprintf(_coverage_fout, "3090\n");
      fflush(_coverage_fout);
      ___coverage_array[3090] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = strlen("year");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3091] == 0) {
      {
      fprintf(_coverage_fout, "3091\n");
      fflush(_coverage_fout);
      ___coverage_array[3091] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "year", tmp___0 + 1U, (long )parsed_time->y);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3190] == 0) {
    {
    fprintf(_coverage_fout, "3190\n");
    fflush(_coverage_fout);
    ___coverage_array[3190] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->m == -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3092] == 0) {
      {
      fprintf(_coverage_fout, "3092\n");
      fflush(_coverage_fout);
      ___coverage_array[3092] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = strlen("month");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3093] == 0) {
      {
      fprintf(_coverage_fout, "3093\n");
      fflush(_coverage_fout);
      ___coverage_array[3093] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "month", tmp___1 + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3094] == 0) {
      {
      fprintf(_coverage_fout, "3094\n");
      fflush(_coverage_fout);
      ___coverage_array[3094] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = strlen("month");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3095] == 0) {
      {
      fprintf(_coverage_fout, "3095\n");
      fflush(_coverage_fout);
      ___coverage_array[3095] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "month", tmp___2 + 1U, (long )parsed_time->m);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3191] == 0) {
    {
    fprintf(_coverage_fout, "3191\n");
    fflush(_coverage_fout);
    ___coverage_array[3191] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->d == -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3096] == 0) {
      {
      fprintf(_coverage_fout, "3096\n");
      fflush(_coverage_fout);
      ___coverage_array[3096] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = strlen("day");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3097] == 0) {
      {
      fprintf(_coverage_fout, "3097\n");
      fflush(_coverage_fout);
      ___coverage_array[3097] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "day", tmp___3 + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3098] == 0) {
      {
      fprintf(_coverage_fout, "3098\n");
      fflush(_coverage_fout);
      ___coverage_array[3098] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = strlen("day");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3099] == 0) {
      {
      fprintf(_coverage_fout, "3099\n");
      fflush(_coverage_fout);
      ___coverage_array[3099] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "day", tmp___4 + 1U, (long )parsed_time->d);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3192] == 0) {
    {
    fprintf(_coverage_fout, "3192\n");
    fflush(_coverage_fout);
    ___coverage_array[3192] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->h == -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3100] == 0) {
      {
      fprintf(_coverage_fout, "3100\n");
      fflush(_coverage_fout);
      ___coverage_array[3100] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = strlen("hour");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3101] == 0) {
      {
      fprintf(_coverage_fout, "3101\n");
      fflush(_coverage_fout);
      ___coverage_array[3101] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "hour", tmp___5 + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3102] == 0) {
      {
      fprintf(_coverage_fout, "3102\n");
      fflush(_coverage_fout);
      ___coverage_array[3102] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = strlen("hour");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3103] == 0) {
      {
      fprintf(_coverage_fout, "3103\n");
      fflush(_coverage_fout);
      ___coverage_array[3103] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "hour", tmp___6 + 1U, (long )parsed_time->h);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3193] == 0) {
    {
    fprintf(_coverage_fout, "3193\n");
    fflush(_coverage_fout);
    ___coverage_array[3193] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->i == -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3104] == 0) {
      {
      fprintf(_coverage_fout, "3104\n");
      fflush(_coverage_fout);
      ___coverage_array[3104] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = strlen("minute");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3105] == 0) {
      {
      fprintf(_coverage_fout, "3105\n");
      fflush(_coverage_fout);
      ___coverage_array[3105] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "minute", tmp___7 + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3106] == 0) {
      {
      fprintf(_coverage_fout, "3106\n");
      fflush(_coverage_fout);
      ___coverage_array[3106] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___8 = strlen("minute");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3107] == 0) {
      {
      fprintf(_coverage_fout, "3107\n");
      fflush(_coverage_fout);
      ___coverage_array[3107] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "minute", tmp___8 + 1U,
                      (long )parsed_time->i);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3194] == 0) {
    {
    fprintf(_coverage_fout, "3194\n");
    fflush(_coverage_fout);
    ___coverage_array[3194] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->s == -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3108] == 0) {
      {
      fprintf(_coverage_fout, "3108\n");
      fflush(_coverage_fout);
      ___coverage_array[3108] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = strlen("second");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3109] == 0) {
      {
      fprintf(_coverage_fout, "3109\n");
      fflush(_coverage_fout);
      ___coverage_array[3109] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "second", tmp___9 + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3110] == 0) {
      {
      fprintf(_coverage_fout, "3110\n");
      fflush(_coverage_fout);
      ___coverage_array[3110] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = strlen("second");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3111] == 0) {
      {
      fprintf(_coverage_fout, "3111\n");
      fflush(_coverage_fout);
      ___coverage_array[3111] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(return_value, "second", tmp___10 + 1U,
                      (long )parsed_time->s);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3195] == 0) {
    {
    fprintf(_coverage_fout, "3195\n");
    fflush(_coverage_fout);
    ___coverage_array[3195] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->f == (double )-99999) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3112] == 0) {
      {
      fprintf(_coverage_fout, "3112\n");
      fflush(_coverage_fout);
      ___coverage_array[3112] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___11 = strlen("fraction");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3113] == 0) {
      {
      fprintf(_coverage_fout, "3113\n");
      fflush(_coverage_fout);
      ___coverage_array[3113] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "fraction", tmp___11 + 1U, 0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3114] == 0) {
      {
      fprintf(_coverage_fout, "3114\n");
      fflush(_coverage_fout);
      ___coverage_array[3114] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___12 = strlen("fraction");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3115] == 0) {
      {
      fprintf(_coverage_fout, "3115\n");
      fflush(_coverage_fout);
      ___coverage_array[3115] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_double_ex(return_value, "fraction", tmp___12 + 1U, parsed_time->f);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3196] == 0) {
    {
    fprintf(_coverage_fout, "3196\n");
    fflush(_coverage_fout);
    ___coverage_array[3196] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_from_error_container(return_value, error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3197] == 0) {
    {
    fprintf(_coverage_fout, "3197\n");
    fflush(_coverage_fout);
    ___coverage_array[3197] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_error_container_dtor(error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3198] == 0) {
    {
    fprintf(_coverage_fout, "3198\n");
    fflush(_coverage_fout);
    ___coverage_array[3198] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___13 = strlen("is_localtime");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3199] == 0) {
    {
    fprintf(_coverage_fout, "3199\n");
    fflush(_coverage_fout);
    ___coverage_array[3199] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "is_localtime", tmp___13 + 1U,
                    (int )parsed_time->is_localtime);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3200] == 0) {
    {
    fprintf(_coverage_fout, "3200\n");
    fflush(_coverage_fout);
    ___coverage_array[3200] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->is_localtime) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3144] == 0) {
      {
      fprintf(_coverage_fout, "3144\n");
      fflush(_coverage_fout);
      ___coverage_array[3144] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (parsed_time->zone_type == 4294867297U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3116] == 0) {
        {
        fprintf(_coverage_fout, "3116\n");
        fflush(_coverage_fout);
        ___coverage_array[3116] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___14 = strlen("zone_type");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3117] == 0) {
        {
        fprintf(_coverage_fout, "3117\n");
        fflush(_coverage_fout);
        ___coverage_array[3117] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_bool_ex(return_value, "zone_type", tmp___14 + 1U, 0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3118] == 0) {
        {
        fprintf(_coverage_fout, "3118\n");
        fflush(_coverage_fout);
        ___coverage_array[3118] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___15 = strlen("zone_type");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3119] == 0) {
        {
        fprintf(_coverage_fout, "3119\n");
        fflush(_coverage_fout);
        ___coverage_array[3119] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(return_value, "zone_type", tmp___15 + 1U,
                        (long )parsed_time->zone_type);
    }
    switch ((int )parsed_time->zone_type) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3134] == 0) {
      {
      fprintf(_coverage_fout, "3134\n");
      fflush(_coverage_fout);
      ___coverage_array[3134] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 1: 
    if (parsed_time->z == -99999) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3120] == 0) {
        {
        fprintf(_coverage_fout, "3120\n");
        fflush(_coverage_fout);
        ___coverage_array[3120] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___16 = strlen("zone");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3121] == 0) {
        {
        fprintf(_coverage_fout, "3121\n");
        fflush(_coverage_fout);
        ___coverage_array[3121] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_bool_ex(return_value, "zone", tmp___16 + 1U, 0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3122] == 0) {
        {
        fprintf(_coverage_fout, "3122\n");
        fflush(_coverage_fout);
        ___coverage_array[3122] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___17 = strlen("zone");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3123] == 0) {
        {
        fprintf(_coverage_fout, "3123\n");
        fflush(_coverage_fout);
        ___coverage_array[3123] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(return_value, "zone", tmp___17 + 1U,
                        (long )parsed_time->z);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3135] == 0) {
      {
      fprintf(_coverage_fout, "3135\n");
      fflush(_coverage_fout);
      ___coverage_array[3135] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___18 = strlen("is_dst");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3136] == 0) {
      {
      fprintf(_coverage_fout, "3136\n");
      fflush(_coverage_fout);
      ___coverage_array[3136] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "is_dst", tmp___18 + 1U, parsed_time->dst);
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3137] == 0) {
      {
      fprintf(_coverage_fout, "3137\n");
      fflush(_coverage_fout);
      ___coverage_array[3137] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 3: 
    if (parsed_time->tz_abbr) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3124] == 0) {
        {
        fprintf(_coverage_fout, "3124\n");
        fflush(_coverage_fout);
        ___coverage_array[3124] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___19 = strlen("tz_abbr");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3125] == 0) {
        {
        fprintf(_coverage_fout, "3125\n");
        fflush(_coverage_fout);
        ___coverage_array[3125] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(return_value, "tz_abbr", tmp___19 + 1U,
                          parsed_time->tz_abbr, 1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3126] == 0) {
        {
        fprintf(_coverage_fout, "3126\n");
        fflush(_coverage_fout);
        ___coverage_array[3126] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3138] == 0) {
      {
      fprintf(_coverage_fout, "3138\n");
      fflush(_coverage_fout);
      ___coverage_array[3138] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (parsed_time->tz_info) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3127] == 0) {
        {
        fprintf(_coverage_fout, "3127\n");
        fflush(_coverage_fout);
        ___coverage_array[3127] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___20 = strlen("tz_id");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3128] == 0) {
        {
        fprintf(_coverage_fout, "3128\n");
        fflush(_coverage_fout);
        ___coverage_array[3128] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(return_value, "tz_id", tmp___20 + 1U,
                          (parsed_time->tz_info)->name, 1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3129] == 0) {
        {
        fprintf(_coverage_fout, "3129\n");
        fflush(_coverage_fout);
        ___coverage_array[3129] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3139] == 0) {
      {
      fprintf(_coverage_fout, "3139\n");
      fflush(_coverage_fout);
      ___coverage_array[3139] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 2: 
    if (parsed_time->z == -99999) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3130] == 0) {
        {
        fprintf(_coverage_fout, "3130\n");
        fflush(_coverage_fout);
        ___coverage_array[3130] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___21 = strlen("zone");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3131] == 0) {
        {
        fprintf(_coverage_fout, "3131\n");
        fflush(_coverage_fout);
        ___coverage_array[3131] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_bool_ex(return_value, "zone", tmp___21 + 1U, 0);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3132] == 0) {
        {
        fprintf(_coverage_fout, "3132\n");
        fflush(_coverage_fout);
        ___coverage_array[3132] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___22 = strlen("zone");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3133] == 0) {
        {
        fprintf(_coverage_fout, "3133\n");
        fflush(_coverage_fout);
        ___coverage_array[3133] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(return_value, "zone", tmp___22 + 1U,
                        (long )parsed_time->z);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3140] == 0) {
      {
      fprintf(_coverage_fout, "3140\n");
      fflush(_coverage_fout);
      ___coverage_array[3140] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___23 = strlen("is_dst");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3141] == 0) {
      {
      fprintf(_coverage_fout, "3141\n");
      fflush(_coverage_fout);
      ___coverage_array[3141] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(return_value, "is_dst", tmp___23 + 1U, parsed_time->dst);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3142] == 0) {
      {
      fprintf(_coverage_fout, "3142\n");
      fflush(_coverage_fout);
      ___coverage_array[3142] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___24 = strlen("tz_abbr");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3143] == 0) {
      {
      fprintf(_coverage_fout, "3143\n");
      fflush(_coverage_fout);
      ___coverage_array[3143] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_string_ex(return_value, "tz_abbr", tmp___24 + 1U,
                        parsed_time->tz_abbr, 1);
    break;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3145] == 0) {
      {
      fprintf(_coverage_fout, "3145\n");
      fflush(_coverage_fout);
      ___coverage_array[3145] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3201] == 0) {
    {
    fprintf(_coverage_fout, "3201\n");
    fflush(_coverage_fout);
    ___coverage_array[3201] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (parsed_time->have_relative) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3166] == 0) {
      {
      fprintf(_coverage_fout, "3166\n");
      fflush(_coverage_fout);
      ___coverage_array[3166] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3146] == 0) {
        {
        fprintf(_coverage_fout, "3146\n");
        fflush(_coverage_fout);
        ___coverage_array[3146] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___25 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3147] == 0) {
        {
        fprintf(_coverage_fout, "3147\n");
        fflush(_coverage_fout);
        ___coverage_array[3147] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element = (zval *)tmp___25;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3148] == 0) {
        {
        fprintf(_coverage_fout, "3148\n");
        fflush(_coverage_fout);
        ___coverage_array[3148] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3167] == 0) {
      {
      fprintf(_coverage_fout, "3167\n");
      fflush(_coverage_fout);
      ___coverage_array[3167] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3168] == 0) {
      {
      fprintf(_coverage_fout, "3168\n");
      fflush(_coverage_fout);
      ___coverage_array[3168] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3169] == 0) {
      {
      fprintf(_coverage_fout, "3169\n");
      fflush(_coverage_fout);
      ___coverage_array[3169] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _array_init(element, 0U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3170] == 0) {
      {
      fprintf(_coverage_fout, "3170\n");
      fflush(_coverage_fout);
      ___coverage_array[3170] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___26 = strlen("year");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3171] == 0) {
      {
      fprintf(_coverage_fout, "3171\n");
      fflush(_coverage_fout);
      ___coverage_array[3171] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "year", tmp___26 + 1U,
                      (long )parsed_time->relative.y);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3172] == 0) {
      {
      fprintf(_coverage_fout, "3172\n");
      fflush(_coverage_fout);
      ___coverage_array[3172] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___27 = strlen("month");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3173] == 0) {
      {
      fprintf(_coverage_fout, "3173\n");
      fflush(_coverage_fout);
      ___coverage_array[3173] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "month", tmp___27 + 1U,
                      (long )parsed_time->relative.m);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3174] == 0) {
      {
      fprintf(_coverage_fout, "3174\n");
      fflush(_coverage_fout);
      ___coverage_array[3174] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___28 = strlen("day");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3175] == 0) {
      {
      fprintf(_coverage_fout, "3175\n");
      fflush(_coverage_fout);
      ___coverage_array[3175] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "day", tmp___28 + 1U,
                      (long )parsed_time->relative.d);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3176] == 0) {
      {
      fprintf(_coverage_fout, "3176\n");
      fflush(_coverage_fout);
      ___coverage_array[3176] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___29 = strlen("hour");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3177] == 0) {
      {
      fprintf(_coverage_fout, "3177\n");
      fflush(_coverage_fout);
      ___coverage_array[3177] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "hour", tmp___29 + 1U,
                      (long )parsed_time->relative.h);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3178] == 0) {
      {
      fprintf(_coverage_fout, "3178\n");
      fflush(_coverage_fout);
      ___coverage_array[3178] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___30 = strlen("minute");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3179] == 0) {
      {
      fprintf(_coverage_fout, "3179\n");
      fflush(_coverage_fout);
      ___coverage_array[3179] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "minute", tmp___30 + 1U,
                      (long )parsed_time->relative.i);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3180] == 0) {
      {
      fprintf(_coverage_fout, "3180\n");
      fflush(_coverage_fout);
      ___coverage_array[3180] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___31 = strlen("second");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3181] == 0) {
      {
      fprintf(_coverage_fout, "3181\n");
      fflush(_coverage_fout);
      ___coverage_array[3181] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "second", tmp___31 + 1U,
                      (long )parsed_time->relative.s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3182] == 0) {
      {
      fprintf(_coverage_fout, "3182\n");
      fflush(_coverage_fout);
      ___coverage_array[3182] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (parsed_time->relative.have_weekday_relative) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3149] == 0) {
        {
        fprintf(_coverage_fout, "3149\n");
        fflush(_coverage_fout);
        ___coverage_array[3149] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___32 = strlen("weekday");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3150] == 0) {
        {
        fprintf(_coverage_fout, "3150\n");
        fflush(_coverage_fout);
        ___coverage_array[3150] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(element, "weekday", tmp___32 + 1U,
                        (long )parsed_time->relative.weekday);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3151] == 0) {
        {
        fprintf(_coverage_fout, "3151\n");
        fflush(_coverage_fout);
        ___coverage_array[3151] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3183] == 0) {
      {
      fprintf(_coverage_fout, "3183\n");
      fflush(_coverage_fout);
      ___coverage_array[3183] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (parsed_time->relative.have_special_relative) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3155] == 0) {
        {
        fprintf(_coverage_fout, "3155\n");
        fflush(_coverage_fout);
        ___coverage_array[3155] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (parsed_time->relative.special.type == 1U) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3152] == 0) {
          {
          fprintf(_coverage_fout, "3152\n");
          fflush(_coverage_fout);
          ___coverage_array[3152] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___33 = strlen("weekdays");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3153] == 0) {
          {
          fprintf(_coverage_fout, "3153\n");
          fflush(_coverage_fout);
          ___coverage_array[3153] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_assoc_long_ex(element, "weekdays", tmp___33 + 1U,
                          (long )parsed_time->relative.special.amount);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3154] == 0) {
          {
          fprintf(_coverage_fout, "3154\n");
          fflush(_coverage_fout);
          ___coverage_array[3154] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3156] == 0) {
        {
        fprintf(_coverage_fout, "3156\n");
        fflush(_coverage_fout);
        ___coverage_array[3156] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3184] == 0) {
      {
      fprintf(_coverage_fout, "3184\n");
      fflush(_coverage_fout);
      ___coverage_array[3184] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (parsed_time->relative.first_last_day_of) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3161] == 0) {
        {
        fprintf(_coverage_fout, "3161\n");
        fflush(_coverage_fout);
        ___coverage_array[3161] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (parsed_time->relative.first_last_day_of == 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3157] == 0) {
          {
          fprintf(_coverage_fout, "3157\n");
          fflush(_coverage_fout);
          ___coverage_array[3157] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___34 = "first_day_of_month";
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3158] == 0) {
          {
          fprintf(_coverage_fout, "3158\n");
          fflush(_coverage_fout);
          ___coverage_array[3158] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___34 = "last_day_of_month";
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3162] == 0) {
        {
        fprintf(_coverage_fout, "3162\n");
        fflush(_coverage_fout);
        ___coverage_array[3162] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___35 = strlen(tmp___34);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3163] == 0) {
        {
        fprintf(_coverage_fout, "3163\n");
        fflush(_coverage_fout);
        ___coverage_array[3163] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (parsed_time->relative.first_last_day_of == 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3159] == 0) {
          {
          fprintf(_coverage_fout, "3159\n");
          fflush(_coverage_fout);
          ___coverage_array[3159] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___36 = "first_day_of_month";
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3160] == 0) {
          {
          fprintf(_coverage_fout, "3160\n");
          fflush(_coverage_fout);
          ___coverage_array[3160] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___36 = "last_day_of_month";
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3164] == 0) {
        {
        fprintf(_coverage_fout, "3164\n");
        fflush(_coverage_fout);
        ___coverage_array[3164] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_bool_ex(element, tmp___36, tmp___35 + 1U, 1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3165] == 0) {
        {
        fprintf(_coverage_fout, "3165\n");
        fflush(_coverage_fout);
        ___coverage_array[3165] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3185] == 0) {
      {
      fprintf(_coverage_fout, "3185\n");
      fflush(_coverage_fout);
      ___coverage_array[3185] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___37 = strlen("relative");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3186] == 0) {
      {
      fprintf(_coverage_fout, "3186\n");
      fflush(_coverage_fout);
      ___coverage_array[3186] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_zval_ex(return_value, "relative", tmp___37 + 1U, element);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3187] == 0) {
      {
      fprintf(_coverage_fout, "3187\n");
      fflush(_coverage_fout);
      ___coverage_array[3187] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3202] == 0) {
    {
    fprintf(_coverage_fout, "3202\n");
    fflush(_coverage_fout);
    ___coverage_array[3202] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(parsed_time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3203] == 0) {
    {
    fprintf(_coverage_fout, "3203\n");
    fflush(_coverage_fout);
    ___coverage_array[3203] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_parse(int ht , zval *return_value , zval **return_value_ptr ,
                    zval *this_ptr , int return_value_used ) 
{ char *date ;
  int date_len ;
  struct timelib_error_container *error ;
  timelib_time *parsed_time ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  timelib_tzdb const   *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3213] == 0) {
    {
    fprintf(_coverage_fout, "3213\n");
    fflush(_coverage_fout);
    ___coverage_array[3213] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s", & date, & date_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3214] == 0) {
    {
    fprintf(_coverage_fout, "3214\n");
    fflush(_coverage_fout);
    ___coverage_array[3214] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3207] == 0) {
      {
      fprintf(_coverage_fout, "3207\n");
      fflush(_coverage_fout);
      ___coverage_array[3207] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3204] == 0) {
        {
        fprintf(_coverage_fout, "3204\n");
        fflush(_coverage_fout);
        ___coverage_array[3204] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3205] == 0) {
        {
        fprintf(_coverage_fout, "3205\n");
        fflush(_coverage_fout);
        ___coverage_array[3205] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3206] == 0) {
        {
        fprintf(_coverage_fout, "3206\n");
        fflush(_coverage_fout);
        ___coverage_array[3206] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3208] == 0) {
      {
      fprintf(_coverage_fout, "3208\n");
      fflush(_coverage_fout);
      ___coverage_array[3208] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3209] == 0) {
      {
      fprintf(_coverage_fout, "3209\n");
      fflush(_coverage_fout);
      ___coverage_array[3209] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3215] == 0) {
    {
    fprintf(_coverage_fout, "3215\n");
    fflush(_coverage_fout);
    ___coverage_array[3215] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3210] == 0) {
      {
      fprintf(_coverage_fout, "3210\n");
      fflush(_coverage_fout);
      ___coverage_array[3210] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3211] == 0) {
      {
      fprintf(_coverage_fout, "3211\n");
      fflush(_coverage_fout);
      ___coverage_array[3211] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3212] == 0) {
      {
      fprintf(_coverage_fout, "3212\n");
      fflush(_coverage_fout);
      ___coverage_array[3212] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3216] == 0) {
    {
    fprintf(_coverage_fout, "3216\n");
    fflush(_coverage_fout);
    ___coverage_array[3216] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  parsed_time = timelib_strtotime(date, date_len, & error, tmp___1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3217] == 0) {
    {
    fprintf(_coverage_fout, "3217\n");
    fflush(_coverage_fout);
    ___coverage_array[3217] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_do_return_parsed_time(ht, return_value, return_value_ptr, this_ptr,
                                 return_value_used, parsed_time, error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3218] == 0) {
    {
    fprintf(_coverage_fout, "3218\n");
    fflush(_coverage_fout);
    ___coverage_array[3218] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_parse_from_format(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) 
{ char *date ;
  char *format ;
  int date_len ;
  int format_len ;
  struct timelib_error_container *error ;
  timelib_time *parsed_time ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  timelib_tzdb const   *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3228] == 0) {
    {
    fprintf(_coverage_fout, "3228\n");
    fflush(_coverage_fout);
    ___coverage_array[3228] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "ss", & format, & format_len, & date,
                              & date_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3229] == 0) {
    {
    fprintf(_coverage_fout, "3229\n");
    fflush(_coverage_fout);
    ___coverage_array[3229] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3222] == 0) {
      {
      fprintf(_coverage_fout, "3222\n");
      fflush(_coverage_fout);
      ___coverage_array[3222] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3219] == 0) {
        {
        fprintf(_coverage_fout, "3219\n");
        fflush(_coverage_fout);
        ___coverage_array[3219] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3220] == 0) {
        {
        fprintf(_coverage_fout, "3220\n");
        fflush(_coverage_fout);
        ___coverage_array[3220] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3221] == 0) {
        {
        fprintf(_coverage_fout, "3221\n");
        fflush(_coverage_fout);
        ___coverage_array[3221] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3223] == 0) {
      {
      fprintf(_coverage_fout, "3223\n");
      fflush(_coverage_fout);
      ___coverage_array[3223] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3224] == 0) {
      {
      fprintf(_coverage_fout, "3224\n");
      fflush(_coverage_fout);
      ___coverage_array[3224] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3230] == 0) {
    {
    fprintf(_coverage_fout, "3230\n");
    fflush(_coverage_fout);
    ___coverage_array[3230] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3225] == 0) {
      {
      fprintf(_coverage_fout, "3225\n");
      fflush(_coverage_fout);
      ___coverage_array[3225] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3226] == 0) {
      {
      fprintf(_coverage_fout, "3226\n");
      fflush(_coverage_fout);
      ___coverage_array[3226] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3227] == 0) {
      {
      fprintf(_coverage_fout, "3227\n");
      fflush(_coverage_fout);
      ___coverage_array[3227] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3231] == 0) {
    {
    fprintf(_coverage_fout, "3231\n");
    fflush(_coverage_fout);
    ___coverage_array[3231] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  parsed_time = timelib_parse_from_format(format, date, date_len, & error,
                                          tmp___1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3232] == 0) {
    {
    fprintf(_coverage_fout, "3232\n");
    fflush(_coverage_fout);
    ___coverage_array[3232] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_do_return_parsed_time(ht, return_value, return_value_ptr, this_ptr,
                                 return_value_used, parsed_time, error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3233] == 0) {
    {
    fprintf(_coverage_fout, "3233\n");
    fflush(_coverage_fout);
    ___coverage_array[3233] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_format(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  char *format ;
  int format_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  char const   *__s ;
  char *tmp___1 ;
  zval *__z___1 ;
  size_t tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3254] == 0) {
    {
    fprintf(_coverage_fout, "3254\n");
    fflush(_coverage_fout);
    ___coverage_array[3254] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & object, date_ce_date,
                                     & format, & format_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3255] == 0) {
    {
    fprintf(_coverage_fout, "3255\n");
    fflush(_coverage_fout);
    ___coverage_array[3255] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3237] == 0) {
      {
      fprintf(_coverage_fout, "3237\n");
      fflush(_coverage_fout);
      ___coverage_array[3237] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3234] == 0) {
        {
        fprintf(_coverage_fout, "3234\n");
        fflush(_coverage_fout);
        ___coverage_array[3234] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3235] == 0) {
        {
        fprintf(_coverage_fout, "3235\n");
        fflush(_coverage_fout);
        ___coverage_array[3235] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3236] == 0) {
        {
        fprintf(_coverage_fout, "3236\n");
        fflush(_coverage_fout);
        ___coverage_array[3236] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3238] == 0) {
      {
      fprintf(_coverage_fout, "3238\n");
      fflush(_coverage_fout);
      ___coverage_array[3238] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3239] == 0) {
      {
      fprintf(_coverage_fout, "3239\n");
      fflush(_coverage_fout);
      ___coverage_array[3239] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3256] == 0) {
    {
    fprintf(_coverage_fout, "3256\n");
    fflush(_coverage_fout);
    ___coverage_array[3256] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3257] == 0) {
    {
    fprintf(_coverage_fout, "3257\n");
    fflush(_coverage_fout);
    ___coverage_array[3257] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3258] == 0) {
    {
    fprintf(_coverage_fout, "3258\n");
    fflush(_coverage_fout);
    ___coverage_array[3258] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3243] == 0) {
      {
      fprintf(_coverage_fout, "3243\n");
      fflush(_coverage_fout);
      ___coverage_array[3243] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3244] == 0) {
      {
      fprintf(_coverage_fout, "3244\n");
      fflush(_coverage_fout);
      ___coverage_array[3244] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3240] == 0) {
        {
        fprintf(_coverage_fout, "3240\n");
        fflush(_coverage_fout);
        ___coverage_array[3240] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3241] == 0) {
        {
        fprintf(_coverage_fout, "3241\n");
        fflush(_coverage_fout);
        ___coverage_array[3241] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3242] == 0) {
        {
        fprintf(_coverage_fout, "3242\n");
        fflush(_coverage_fout);
        ___coverage_array[3242] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3245] == 0) {
      {
      fprintf(_coverage_fout, "3245\n");
      fflush(_coverage_fout);
      ___coverage_array[3245] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3246] == 0) {
      {
      fprintf(_coverage_fout, "3246\n");
      fflush(_coverage_fout);
      ___coverage_array[3246] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3259] == 0) {
    {
    fprintf(_coverage_fout, "3259\n");
    fflush(_coverage_fout);
    ___coverage_array[3259] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3247] == 0) {
      {
      fprintf(_coverage_fout, "3247\n");
      fflush(_coverage_fout);
      ___coverage_array[3247] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = date_format(format, format_len, dateobj->time,
                          (int )(dateobj->time)->is_localtime);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3248] == 0) {
      {
      fprintf(_coverage_fout, "3248\n");
      fflush(_coverage_fout);
      ___coverage_array[3248] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3249] == 0) {
      {
      fprintf(_coverage_fout, "3249\n");
      fflush(_coverage_fout);
      ___coverage_array[3249] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3250] == 0) {
      {
      fprintf(_coverage_fout, "3250\n");
      fflush(_coverage_fout);
      ___coverage_array[3250] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3251] == 0) {
      {
      fprintf(_coverage_fout, "3251\n");
      fflush(_coverage_fout);
      ___coverage_array[3251] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.str.len = (int )tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3252] == 0) {
      {
      fprintf(_coverage_fout, "3252\n");
      fflush(_coverage_fout);
      ___coverage_array[3252] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3253] == 0) {
      {
      fprintf(_coverage_fout, "3253\n");
      fflush(_coverage_fout);
      ___coverage_array[3253] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3260] == 0) {
    {
    fprintf(_coverage_fout, "3260\n");
    fflush(_coverage_fout);
    ___coverage_array[3260] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_modify(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  char *modify ;
  int modify_len ;
  timelib_time *tmp_time ;
  timelib_error_container *err ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  timelib_tzdb const   *tmp___1 ;
  timelib_tzdb const   *tmp___2 ;
  zval *__z___1 ;
  zend_uchar is_ref ;
  zend_bool tmp___3 ;
  zend_uint refcount ;
  zend_uint tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3304] == 0) {
    {
    fprintf(_coverage_fout, "3304\n");
    fflush(_coverage_fout);
    ___coverage_array[3304] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  err = (timelib_error_container *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3305] == 0) {
    {
    fprintf(_coverage_fout, "3305\n");
    fflush(_coverage_fout);
    ___coverage_array[3305] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Os", & object, date_ce_date,
                                     & modify, & modify_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3306] == 0) {
    {
    fprintf(_coverage_fout, "3306\n");
    fflush(_coverage_fout);
    ___coverage_array[3306] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3264] == 0) {
      {
      fprintf(_coverage_fout, "3264\n");
      fflush(_coverage_fout);
      ___coverage_array[3264] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3261] == 0) {
        {
        fprintf(_coverage_fout, "3261\n");
        fflush(_coverage_fout);
        ___coverage_array[3261] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3262] == 0) {
        {
        fprintf(_coverage_fout, "3262\n");
        fflush(_coverage_fout);
        ___coverage_array[3262] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3263] == 0) {
        {
        fprintf(_coverage_fout, "3263\n");
        fflush(_coverage_fout);
        ___coverage_array[3263] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3265] == 0) {
      {
      fprintf(_coverage_fout, "3265\n");
      fflush(_coverage_fout);
      ___coverage_array[3265] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3266] == 0) {
      {
      fprintf(_coverage_fout, "3266\n");
      fflush(_coverage_fout);
      ___coverage_array[3266] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3307] == 0) {
    {
    fprintf(_coverage_fout, "3307\n");
    fflush(_coverage_fout);
    ___coverage_array[3307] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3308] == 0) {
    {
    fprintf(_coverage_fout, "3308\n");
    fflush(_coverage_fout);
    ___coverage_array[3308] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3309] == 0) {
    {
    fprintf(_coverage_fout, "3309\n");
    fflush(_coverage_fout);
    ___coverage_array[3309] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3270] == 0) {
      {
      fprintf(_coverage_fout, "3270\n");
      fflush(_coverage_fout);
      ___coverage_array[3270] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3271] == 0) {
      {
      fprintf(_coverage_fout, "3271\n");
      fflush(_coverage_fout);
      ___coverage_array[3271] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3267] == 0) {
        {
        fprintf(_coverage_fout, "3267\n");
        fflush(_coverage_fout);
        ___coverage_array[3267] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3268] == 0) {
        {
        fprintf(_coverage_fout, "3268\n");
        fflush(_coverage_fout);
        ___coverage_array[3268] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3269] == 0) {
        {
        fprintf(_coverage_fout, "3269\n");
        fflush(_coverage_fout);
        ___coverage_array[3269] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3272] == 0) {
      {
      fprintf(_coverage_fout, "3272\n");
      fflush(_coverage_fout);
      ___coverage_array[3272] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3273] == 0) {
      {
      fprintf(_coverage_fout, "3273\n");
      fflush(_coverage_fout);
      ___coverage_array[3273] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3310] == 0) {
    {
    fprintf(_coverage_fout, "3310\n");
    fflush(_coverage_fout);
    ___coverage_array[3310] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3274] == 0) {
      {
      fprintf(_coverage_fout, "3274\n");
      fflush(_coverage_fout);
      ___coverage_array[3274] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3275] == 0) {
      {
      fprintf(_coverage_fout, "3275\n");
      fflush(_coverage_fout);
      ___coverage_array[3275] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3276] == 0) {
      {
      fprintf(_coverage_fout, "3276\n");
      fflush(_coverage_fout);
      ___coverage_array[3276] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = tmp___1;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3311] == 0) {
    {
    fprintf(_coverage_fout, "3311\n");
    fflush(_coverage_fout);
    ___coverage_array[3311] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp_time = timelib_strtotime(modify, modify_len, & err, tmp___2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3312] == 0) {
    {
    fprintf(_coverage_fout, "3312\n");
    fflush(_coverage_fout);
    ___coverage_array[3312] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  update_errors_warnings(err);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3313] == 0) {
    {
    fprintf(_coverage_fout, "3313\n");
    fflush(_coverage_fout);
    ___coverage_array[3313] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (err) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3285] == 0) {
      {
      fprintf(_coverage_fout, "3285\n");
      fflush(_coverage_fout);
      ___coverage_array[3285] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (err->error_count) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3280] == 0) {
        {
        fprintf(_coverage_fout, "3280\n");
        fflush(_coverage_fout);
        ___coverage_array[3280] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "Failed to parse time string (%s) at position %d (%c): %s",
                        modify, (err->error_messages + 0)->position,
                        (err->error_messages + 0)->character,
                        (err->error_messages + 0)->message);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3281] == 0) {
        {
        fprintf(_coverage_fout, "3281\n");
        fflush(_coverage_fout);
        ___coverage_array[3281] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_time_dtor(tmp_time);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3282] == 0) {
        {
        fprintf(_coverage_fout, "3282\n");
        fflush(_coverage_fout);
        ___coverage_array[3282] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3277] == 0) {
          {
          fprintf(_coverage_fout, "3277\n");
          fflush(_coverage_fout);
          ___coverage_array[3277] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1 = return_value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3278] == 0) {
          {
          fprintf(_coverage_fout, "3278\n");
          fflush(_coverage_fout);
          ___coverage_array[3278] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->value.lval = 0L;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3279] == 0) {
          {
          fprintf(_coverage_fout, "3279\n");
          fflush(_coverage_fout);
          ___coverage_array[3279] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___1->type = (unsigned char)3;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3283] == 0) {
        {
        fprintf(_coverage_fout, "3283\n");
        fflush(_coverage_fout);
        ___coverage_array[3283] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3284] == 0) {
        {
        fprintf(_coverage_fout, "3284\n");
        fflush(_coverage_fout);
        ___coverage_array[3284] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3286] == 0) {
      {
      fprintf(_coverage_fout, "3286\n");
      fflush(_coverage_fout);
      ___coverage_array[3286] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3314] == 0) {
    {
    fprintf(_coverage_fout, "3314\n");
    fflush(_coverage_fout);
    ___coverage_array[3314] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memcpy((void */* __restrict  */)(& (dateobj->time)->relative),
         (void const   */* __restrict  */)(& tmp_time->relative),
         sizeof(struct timelib_rel_time ));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3315] == 0) {
    {
    fprintf(_coverage_fout, "3315\n");
    fflush(_coverage_fout);
    ___coverage_array[3315] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = tmp_time->have_relative;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3316] == 0) {
    {
    fprintf(_coverage_fout, "3316\n");
    fflush(_coverage_fout);
    ___coverage_array[3316] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->sse_uptodate = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3317] == 0) {
    {
    fprintf(_coverage_fout, "3317\n");
    fflush(_coverage_fout);
    ___coverage_array[3317] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp_time->y != -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3287] == 0) {
      {
      fprintf(_coverage_fout, "3287\n");
      fflush(_coverage_fout);
      ___coverage_array[3287] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (dateobj->time)->y = tmp_time->y;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3288] == 0) {
      {
      fprintf(_coverage_fout, "3288\n");
      fflush(_coverage_fout);
      ___coverage_array[3288] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3318] == 0) {
    {
    fprintf(_coverage_fout, "3318\n");
    fflush(_coverage_fout);
    ___coverage_array[3318] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp_time->m != -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3289] == 0) {
      {
      fprintf(_coverage_fout, "3289\n");
      fflush(_coverage_fout);
      ___coverage_array[3289] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (dateobj->time)->m = tmp_time->m;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3290] == 0) {
      {
      fprintf(_coverage_fout, "3290\n");
      fflush(_coverage_fout);
      ___coverage_array[3290] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3319] == 0) {
    {
    fprintf(_coverage_fout, "3319\n");
    fflush(_coverage_fout);
    ___coverage_array[3319] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp_time->d != -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3291] == 0) {
      {
      fprintf(_coverage_fout, "3291\n");
      fflush(_coverage_fout);
      ___coverage_array[3291] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (dateobj->time)->d = tmp_time->d;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3292] == 0) {
      {
      fprintf(_coverage_fout, "3292\n");
      fflush(_coverage_fout);
      ___coverage_array[3292] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3320] == 0) {
    {
    fprintf(_coverage_fout, "3320\n");
    fflush(_coverage_fout);
    ___coverage_array[3320] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp_time->h != -99999LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3299] == 0) {
      {
      fprintf(_coverage_fout, "3299\n");
      fflush(_coverage_fout);
      ___coverage_array[3299] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (dateobj->time)->h = tmp_time->h;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3300] == 0) {
      {
      fprintf(_coverage_fout, "3300\n");
      fflush(_coverage_fout);
      ___coverage_array[3300] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp_time->i != -99999LL) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3295] == 0) {
        {
        fprintf(_coverage_fout, "3295\n");
        fflush(_coverage_fout);
        ___coverage_array[3295] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->i = tmp_time->i;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3296] == 0) {
        {
        fprintf(_coverage_fout, "3296\n");
        fflush(_coverage_fout);
        ___coverage_array[3296] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp_time->s != -99999LL) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3293] == 0) {
          {
          fprintf(_coverage_fout, "3293\n");
          fflush(_coverage_fout);
          ___coverage_array[3293] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        (dateobj->time)->s = tmp_time->s;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3294] == 0) {
          {
          fprintf(_coverage_fout, "3294\n");
          fflush(_coverage_fout);
          ___coverage_array[3294] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        (dateobj->time)->s = 0LL;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3297] == 0) {
        {
        fprintf(_coverage_fout, "3297\n");
        fflush(_coverage_fout);
        ___coverage_array[3297] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->i = 0LL;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3298] == 0) {
        {
        fprintf(_coverage_fout, "3298\n");
        fflush(_coverage_fout);
        ___coverage_array[3298] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->s = 0LL;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3301] == 0) {
      {
      fprintf(_coverage_fout, "3301\n");
      fflush(_coverage_fout);
      ___coverage_array[3301] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3321] == 0) {
    {
    fprintf(_coverage_fout, "3321\n");
    fflush(_coverage_fout);
    ___coverage_array[3321] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(tmp_time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3322] == 0) {
    {
    fprintf(_coverage_fout, "3322\n");
    fflush(_coverage_fout);
    ___coverage_array[3322] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3323] == 0) {
    {
    fprintf(_coverage_fout, "3323\n");
    fflush(_coverage_fout);
    ___coverage_array[3323] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_from_sse(dateobj->time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3324] == 0) {
    {
    fprintf(_coverage_fout, "3324\n");
    fflush(_coverage_fout);
    ___coverage_array[3324] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3325] == 0) {
    {
    fprintf(_coverage_fout, "3325\n");
    fflush(_coverage_fout);
    ___coverage_array[3325] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3326] == 0) {
    {
    fprintf(_coverage_fout, "3326\n");
    fflush(_coverage_fout);
    ___coverage_array[3326] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3327] == 0) {
    {
    fprintf(_coverage_fout, "3327\n");
    fflush(_coverage_fout);
    ___coverage_array[3327] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3328] == 0) {
    {
    fprintf(_coverage_fout, "3328\n");
    fflush(_coverage_fout);
    ___coverage_array[3328] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___4;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3329] == 0) {
    {
    fprintf(_coverage_fout, "3329\n");
    fflush(_coverage_fout);
    ___coverage_array[3329] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3302] == 0) {
      {
      fprintf(_coverage_fout, "3302\n");
      fflush(_coverage_fout);
      ___coverage_array[3302] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3303] == 0) {
      {
      fprintf(_coverage_fout, "3303\n");
      fflush(_coverage_fout);
      ___coverage_array[3303] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3330] == 0) {
    {
    fprintf(_coverage_fout, "3330\n");
    fflush(_coverage_fout);
    ___coverage_array[3330] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3331] == 0) {
    {
    fprintf(_coverage_fout, "3331\n");
    fflush(_coverage_fout);
    ___coverage_array[3331] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3332] == 0) {
    {
    fprintf(_coverage_fout, "3332\n");
    fflush(_coverage_fout);
    ___coverage_array[3332] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3333] == 0) {
    {
    fprintf(_coverage_fout, "3333\n");
    fflush(_coverage_fout);
    ___coverage_array[3333] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_add(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) 
{ zval *object ;
  zval *interval ;
  php_date_obj *dateobj ;
  php_interval_obj *intobj ;
  int bias ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z___1 ;
  zend_uchar is_ref ;
  zend_bool tmp___2 ;
  zend_uint refcount ;
  zend_uint tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3370] == 0) {
    {
    fprintf(_coverage_fout, "3370\n");
    fflush(_coverage_fout);
    ___coverage_array[3370] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  bias = 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3371] == 0) {
    {
    fprintf(_coverage_fout, "3371\n");
    fflush(_coverage_fout);
    ___coverage_array[3371] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "OO", & object, date_ce_date,
                                     & interval, date_ce_interval);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3372] == 0) {
    {
    fprintf(_coverage_fout, "3372\n");
    fflush(_coverage_fout);
    ___coverage_array[3372] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3337] == 0) {
      {
      fprintf(_coverage_fout, "3337\n");
      fflush(_coverage_fout);
      ___coverage_array[3337] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3334] == 0) {
        {
        fprintf(_coverage_fout, "3334\n");
        fflush(_coverage_fout);
        ___coverage_array[3334] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3335] == 0) {
        {
        fprintf(_coverage_fout, "3335\n");
        fflush(_coverage_fout);
        ___coverage_array[3335] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3336] == 0) {
        {
        fprintf(_coverage_fout, "3336\n");
        fflush(_coverage_fout);
        ___coverage_array[3336] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3338] == 0) {
      {
      fprintf(_coverage_fout, "3338\n");
      fflush(_coverage_fout);
      ___coverage_array[3338] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3339] == 0) {
      {
      fprintf(_coverage_fout, "3339\n");
      fflush(_coverage_fout);
      ___coverage_array[3339] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3373] == 0) {
    {
    fprintf(_coverage_fout, "3373\n");
    fflush(_coverage_fout);
    ___coverage_array[3373] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3374] == 0) {
    {
    fprintf(_coverage_fout, "3374\n");
    fflush(_coverage_fout);
    ___coverage_array[3374] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3375] == 0) {
    {
    fprintf(_coverage_fout, "3375\n");
    fflush(_coverage_fout);
    ___coverage_array[3375] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3343] == 0) {
      {
      fprintf(_coverage_fout, "3343\n");
      fflush(_coverage_fout);
      ___coverage_array[3343] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3344] == 0) {
      {
      fprintf(_coverage_fout, "3344\n");
      fflush(_coverage_fout);
      ___coverage_array[3344] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3340] == 0) {
        {
        fprintf(_coverage_fout, "3340\n");
        fflush(_coverage_fout);
        ___coverage_array[3340] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3341] == 0) {
        {
        fprintf(_coverage_fout, "3341\n");
        fflush(_coverage_fout);
        ___coverage_array[3341] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3342] == 0) {
        {
        fprintf(_coverage_fout, "3342\n");
        fflush(_coverage_fout);
        ___coverage_array[3342] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3345] == 0) {
      {
      fprintf(_coverage_fout, "3345\n");
      fflush(_coverage_fout);
      ___coverage_array[3345] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3346] == 0) {
      {
      fprintf(_coverage_fout, "3346\n");
      fflush(_coverage_fout);
      ___coverage_array[3346] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3376] == 0) {
    {
    fprintf(_coverage_fout, "3376\n");
    fflush(_coverage_fout);
    ___coverage_array[3376] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)interval);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3377] == 0) {
    {
    fprintf(_coverage_fout, "3377\n");
    fflush(_coverage_fout);
    ___coverage_array[3377] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intobj = (php_interval_obj *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3378] == 0) {
    {
    fprintf(_coverage_fout, "3378\n");
    fflush(_coverage_fout);
    ___coverage_array[3378] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! intobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3350] == 0) {
      {
      fprintf(_coverage_fout, "3350\n");
      fflush(_coverage_fout);
      ___coverage_array[3350] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateInterval object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3351] == 0) {
      {
      fprintf(_coverage_fout, "3351\n");
      fflush(_coverage_fout);
      ___coverage_array[3351] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3347] == 0) {
        {
        fprintf(_coverage_fout, "3347\n");
        fflush(_coverage_fout);
        ___coverage_array[3347] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3348] == 0) {
        {
        fprintf(_coverage_fout, "3348\n");
        fflush(_coverage_fout);
        ___coverage_array[3348] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3349] == 0) {
        {
        fprintf(_coverage_fout, "3349\n");
        fflush(_coverage_fout);
        ___coverage_array[3349] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3352] == 0) {
      {
      fprintf(_coverage_fout, "3352\n");
      fflush(_coverage_fout);
      ___coverage_array[3352] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3353] == 0) {
      {
      fprintf(_coverage_fout, "3353\n");
      fflush(_coverage_fout);
      ___coverage_array[3353] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3379] == 0) {
    {
    fprintf(_coverage_fout, "3379\n");
    fflush(_coverage_fout);
    ___coverage_array[3379] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((intobj->diff)->have_weekday_relative) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3354] == 0) {
      {
      fprintf(_coverage_fout, "3354\n");
      fflush(_coverage_fout);
      ___coverage_array[3354] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    memcpy((void */* __restrict  */)(& (dateobj->time)->relative),
           (void const   */* __restrict  */)intobj->diff,
           sizeof(struct timelib_rel_time ));
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3367] == 0) {
      {
      fprintf(_coverage_fout, "3367\n");
      fflush(_coverage_fout);
      ___coverage_array[3367] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((intobj->diff)->have_special_relative) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3355] == 0) {
        {
        fprintf(_coverage_fout, "3355\n");
        fflush(_coverage_fout);
        ___coverage_array[3355] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      memcpy((void */* __restrict  */)(& (dateobj->time)->relative),
             (void const   */* __restrict  */)intobj->diff,
             sizeof(struct timelib_rel_time ));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3358] == 0) {
        {
        fprintf(_coverage_fout, "3358\n");
        fflush(_coverage_fout);
        ___coverage_array[3358] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((intobj->diff)->invert) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3356] == 0) {
          {
          fprintf(_coverage_fout, "3356\n");
          fflush(_coverage_fout);
          ___coverage_array[3356] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        bias = -1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[3357] == 0) {
          {
          fprintf(_coverage_fout, "3357\n");
          fflush(_coverage_fout);
          ___coverage_array[3357] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3359] == 0) {
        {
        fprintf(_coverage_fout, "3359\n");
        fflush(_coverage_fout);
        ___coverage_array[3359] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.y = (intobj->diff)->y * (timelib_sll )bias;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3360] == 0) {
        {
        fprintf(_coverage_fout, "3360\n");
        fflush(_coverage_fout);
        ___coverage_array[3360] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.m = (intobj->diff)->m * (timelib_sll )bias;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3361] == 0) {
        {
        fprintf(_coverage_fout, "3361\n");
        fflush(_coverage_fout);
        ___coverage_array[3361] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.d = (intobj->diff)->d * (timelib_sll )bias;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3362] == 0) {
        {
        fprintf(_coverage_fout, "3362\n");
        fflush(_coverage_fout);
        ___coverage_array[3362] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.h = (intobj->diff)->h * (timelib_sll )bias;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3363] == 0) {
        {
        fprintf(_coverage_fout, "3363\n");
        fflush(_coverage_fout);
        ___coverage_array[3363] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.i = (intobj->diff)->i * (timelib_sll )bias;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3364] == 0) {
        {
        fprintf(_coverage_fout, "3364\n");
        fflush(_coverage_fout);
        ___coverage_array[3364] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.s = (intobj->diff)->s * (timelib_sll )bias;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3365] == 0) {
        {
        fprintf(_coverage_fout, "3365\n");
        fflush(_coverage_fout);
        ___coverage_array[3365] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.weekday = 0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3366] == 0) {
        {
        fprintf(_coverage_fout, "3366\n");
        fflush(_coverage_fout);
        ___coverage_array[3366] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (dateobj->time)->relative.have_weekday_relative = 0U;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3380] == 0) {
    {
    fprintf(_coverage_fout, "3380\n");
    fflush(_coverage_fout);
    ___coverage_array[3380] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3381] == 0) {
    {
    fprintf(_coverage_fout, "3381\n");
    fflush(_coverage_fout);
    ___coverage_array[3381] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->sse_uptodate = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3382] == 0) {
    {
    fprintf(_coverage_fout, "3382\n");
    fflush(_coverage_fout);
    ___coverage_array[3382] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3383] == 0) {
    {
    fprintf(_coverage_fout, "3383\n");
    fflush(_coverage_fout);
    ___coverage_array[3383] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_from_sse(dateobj->time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3384] == 0) {
    {
    fprintf(_coverage_fout, "3384\n");
    fflush(_coverage_fout);
    ___coverage_array[3384] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3385] == 0) {
    {
    fprintf(_coverage_fout, "3385\n");
    fflush(_coverage_fout);
    ___coverage_array[3385] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3386] == 0) {
    {
    fprintf(_coverage_fout, "3386\n");
    fflush(_coverage_fout);
    ___coverage_array[3386] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3387] == 0) {
    {
    fprintf(_coverage_fout, "3387\n");
    fflush(_coverage_fout);
    ___coverage_array[3387] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3388] == 0) {
    {
    fprintf(_coverage_fout, "3388\n");
    fflush(_coverage_fout);
    ___coverage_array[3388] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3389] == 0) {
    {
    fprintf(_coverage_fout, "3389\n");
    fflush(_coverage_fout);
    ___coverage_array[3389] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3368] == 0) {
      {
      fprintf(_coverage_fout, "3368\n");
      fflush(_coverage_fout);
      ___coverage_array[3368] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3369] == 0) {
      {
      fprintf(_coverage_fout, "3369\n");
      fflush(_coverage_fout);
      ___coverage_array[3369] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3390] == 0) {
    {
    fprintf(_coverage_fout, "3390\n");
    fflush(_coverage_fout);
    ___coverage_array[3390] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3391] == 0) {
    {
    fprintf(_coverage_fout, "3391\n");
    fflush(_coverage_fout);
    ___coverage_array[3391] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3392] == 0) {
    {
    fprintf(_coverage_fout, "3392\n");
    fflush(_coverage_fout);
    ___coverage_array[3392] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3393] == 0) {
    {
    fprintf(_coverage_fout, "3393\n");
    fflush(_coverage_fout);
    ___coverage_array[3393] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_sub(int ht , zval *return_value , zval **return_value_ptr ,
                  zval *this_ptr , int return_value_used ) 
{ zval *object ;
  zval *interval ;
  php_date_obj *dateobj ;
  php_interval_obj *intobj ;
  int bias ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z___1 ;
  zend_uchar is_ref ;
  zend_bool tmp___2 ;
  zend_uint refcount ;
  zend_uint tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3421] == 0) {
    {
    fprintf(_coverage_fout, "3421\n");
    fflush(_coverage_fout);
    ___coverage_array[3421] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  bias = 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3422] == 0) {
    {
    fprintf(_coverage_fout, "3422\n");
    fflush(_coverage_fout);
    ___coverage_array[3422] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "OO", & object, date_ce_date,
                                     & interval, date_ce_interval);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3423] == 0) {
    {
    fprintf(_coverage_fout, "3423\n");
    fflush(_coverage_fout);
    ___coverage_array[3423] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3397] == 0) {
      {
      fprintf(_coverage_fout, "3397\n");
      fflush(_coverage_fout);
      ___coverage_array[3397] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3394] == 0) {
        {
        fprintf(_coverage_fout, "3394\n");
        fflush(_coverage_fout);
        ___coverage_array[3394] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3395] == 0) {
        {
        fprintf(_coverage_fout, "3395\n");
        fflush(_coverage_fout);
        ___coverage_array[3395] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3396] == 0) {
        {
        fprintf(_coverage_fout, "3396\n");
        fflush(_coverage_fout);
        ___coverage_array[3396] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3398] == 0) {
      {
      fprintf(_coverage_fout, "3398\n");
      fflush(_coverage_fout);
      ___coverage_array[3398] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3399] == 0) {
      {
      fprintf(_coverage_fout, "3399\n");
      fflush(_coverage_fout);
      ___coverage_array[3399] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3424] == 0) {
    {
    fprintf(_coverage_fout, "3424\n");
    fflush(_coverage_fout);
    ___coverage_array[3424] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3425] == 0) {
    {
    fprintf(_coverage_fout, "3425\n");
    fflush(_coverage_fout);
    ___coverage_array[3425] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3426] == 0) {
    {
    fprintf(_coverage_fout, "3426\n");
    fflush(_coverage_fout);
    ___coverage_array[3426] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3403] == 0) {
      {
      fprintf(_coverage_fout, "3403\n");
      fflush(_coverage_fout);
      ___coverage_array[3403] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3404] == 0) {
      {
      fprintf(_coverage_fout, "3404\n");
      fflush(_coverage_fout);
      ___coverage_array[3404] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3400] == 0) {
        {
        fprintf(_coverage_fout, "3400\n");
        fflush(_coverage_fout);
        ___coverage_array[3400] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3401] == 0) {
        {
        fprintf(_coverage_fout, "3401\n");
        fflush(_coverage_fout);
        ___coverage_array[3401] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3402] == 0) {
        {
        fprintf(_coverage_fout, "3402\n");
        fflush(_coverage_fout);
        ___coverage_array[3402] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3405] == 0) {
      {
      fprintf(_coverage_fout, "3405\n");
      fflush(_coverage_fout);
      ___coverage_array[3405] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3406] == 0) {
      {
      fprintf(_coverage_fout, "3406\n");
      fflush(_coverage_fout);
      ___coverage_array[3406] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3427] == 0) {
    {
    fprintf(_coverage_fout, "3427\n");
    fflush(_coverage_fout);
    ___coverage_array[3427] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)interval);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3428] == 0) {
    {
    fprintf(_coverage_fout, "3428\n");
    fflush(_coverage_fout);
    ___coverage_array[3428] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  intobj = (php_interval_obj *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3429] == 0) {
    {
    fprintf(_coverage_fout, "3429\n");
    fflush(_coverage_fout);
    ___coverage_array[3429] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! intobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3410] == 0) {
      {
      fprintf(_coverage_fout, "3410\n");
      fflush(_coverage_fout);
      ___coverage_array[3410] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateInterval object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3411] == 0) {
      {
      fprintf(_coverage_fout, "3411\n");
      fflush(_coverage_fout);
      ___coverage_array[3411] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3407] == 0) {
        {
        fprintf(_coverage_fout, "3407\n");
        fflush(_coverage_fout);
        ___coverage_array[3407] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3408] == 0) {
        {
        fprintf(_coverage_fout, "3408\n");
        fflush(_coverage_fout);
        ___coverage_array[3408] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3409] == 0) {
        {
        fprintf(_coverage_fout, "3409\n");
        fflush(_coverage_fout);
        ___coverage_array[3409] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3412] == 0) {
      {
      fprintf(_coverage_fout, "3412\n");
      fflush(_coverage_fout);
      ___coverage_array[3412] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3413] == 0) {
      {
      fprintf(_coverage_fout, "3413\n");
      fflush(_coverage_fout);
      ___coverage_array[3413] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3430] == 0) {
    {
    fprintf(_coverage_fout, "3430\n");
    fflush(_coverage_fout);
    ___coverage_array[3430] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((intobj->diff)->have_special_relative) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3414] == 0) {
      {
      fprintf(_coverage_fout, "3414\n");
      fflush(_coverage_fout);
      ___coverage_array[3414] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Only non-special relative time specifications are supported for subtraction");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3415] == 0) {
      {
      fprintf(_coverage_fout, "3415\n");
      fflush(_coverage_fout);
      ___coverage_array[3415] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3416] == 0) {
      {
      fprintf(_coverage_fout, "3416\n");
      fflush(_coverage_fout);
      ___coverage_array[3416] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3431] == 0) {
    {
    fprintf(_coverage_fout, "3431\n");
    fflush(_coverage_fout);
    ___coverage_array[3431] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((intobj->diff)->invert) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3417] == 0) {
      {
      fprintf(_coverage_fout, "3417\n");
      fflush(_coverage_fout);
      ___coverage_array[3417] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    bias = -1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3418] == 0) {
      {
      fprintf(_coverage_fout, "3418\n");
      fflush(_coverage_fout);
      ___coverage_array[3418] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3432] == 0) {
    {
    fprintf(_coverage_fout, "3432\n");
    fflush(_coverage_fout);
    ___coverage_array[3432] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.y = 0LL - (intobj->diff)->y * (timelib_sll )bias;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3433] == 0) {
    {
    fprintf(_coverage_fout, "3433\n");
    fflush(_coverage_fout);
    ___coverage_array[3433] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.m = 0LL - (intobj->diff)->m * (timelib_sll )bias;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3434] == 0) {
    {
    fprintf(_coverage_fout, "3434\n");
    fflush(_coverage_fout);
    ___coverage_array[3434] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.d = 0LL - (intobj->diff)->d * (timelib_sll )bias;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3435] == 0) {
    {
    fprintf(_coverage_fout, "3435\n");
    fflush(_coverage_fout);
    ___coverage_array[3435] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.h = 0LL - (intobj->diff)->h * (timelib_sll )bias;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3436] == 0) {
    {
    fprintf(_coverage_fout, "3436\n");
    fflush(_coverage_fout);
    ___coverage_array[3436] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.i = 0LL - (intobj->diff)->i * (timelib_sll )bias;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3437] == 0) {
    {
    fprintf(_coverage_fout, "3437\n");
    fflush(_coverage_fout);
    ___coverage_array[3437] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.s = 0LL - (intobj->diff)->s * (timelib_sll )bias;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3438] == 0) {
    {
    fprintf(_coverage_fout, "3438\n");
    fflush(_coverage_fout);
    ___coverage_array[3438] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3439] == 0) {
    {
    fprintf(_coverage_fout, "3439\n");
    fflush(_coverage_fout);
    ___coverage_array[3439] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.weekday = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3440] == 0) {
    {
    fprintf(_coverage_fout, "3440\n");
    fflush(_coverage_fout);
    ___coverage_array[3440] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.have_weekday_relative = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3441] == 0) {
    {
    fprintf(_coverage_fout, "3441\n");
    fflush(_coverage_fout);
    ___coverage_array[3441] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->sse_uptodate = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3442] == 0) {
    {
    fprintf(_coverage_fout, "3442\n");
    fflush(_coverage_fout);
    ___coverage_array[3442] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3443] == 0) {
    {
    fprintf(_coverage_fout, "3443\n");
    fflush(_coverage_fout);
    ___coverage_array[3443] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_from_sse(dateobj->time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3444] == 0) {
    {
    fprintf(_coverage_fout, "3444\n");
    fflush(_coverage_fout);
    ___coverage_array[3444] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3445] == 0) {
    {
    fprintf(_coverage_fout, "3445\n");
    fflush(_coverage_fout);
    ___coverage_array[3445] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3446] == 0) {
    {
    fprintf(_coverage_fout, "3446\n");
    fflush(_coverage_fout);
    ___coverage_array[3446] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3447] == 0) {
    {
    fprintf(_coverage_fout, "3447\n");
    fflush(_coverage_fout);
    ___coverage_array[3447] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3448] == 0) {
    {
    fprintf(_coverage_fout, "3448\n");
    fflush(_coverage_fout);
    ___coverage_array[3448] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3449] == 0) {
    {
    fprintf(_coverage_fout, "3449\n");
    fflush(_coverage_fout);
    ___coverage_array[3449] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3419] == 0) {
      {
      fprintf(_coverage_fout, "3419\n");
      fflush(_coverage_fout);
      ___coverage_array[3419] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3420] == 0) {
      {
      fprintf(_coverage_fout, "3420\n");
      fflush(_coverage_fout);
      ___coverage_array[3420] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3450] == 0) {
    {
    fprintf(_coverage_fout, "3450\n");
    fflush(_coverage_fout);
    ___coverage_array[3450] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3451] == 0) {
    {
    fprintf(_coverage_fout, "3451\n");
    fflush(_coverage_fout);
    ___coverage_array[3451] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3452] == 0) {
    {
    fprintf(_coverage_fout, "3452\n");
    fflush(_coverage_fout);
    ___coverage_array[3452] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3453] == 0) {
    {
    fprintf(_coverage_fout, "3453\n");
    fflush(_coverage_fout);
    ___coverage_array[3453] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_timezone_get(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  php_timezone_obj *tzobj ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  void *tmp___2 ;
  size_t __len ;
  size_t tmp___3 ;
  char *__retval ;
  void *tmp___4 ;
  void *tmp___5 ;
  char *tmp___6 ;
  char *tmp___7 ;
  zval *__z___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3483] == 0) {
    {
    fprintf(_coverage_fout, "3483\n");
    fflush(_coverage_fout);
    ___coverage_array[3483] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & object, date_ce_date);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3484] == 0) {
    {
    fprintf(_coverage_fout, "3484\n");
    fflush(_coverage_fout);
    ___coverage_array[3484] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3457] == 0) {
      {
      fprintf(_coverage_fout, "3457\n");
      fflush(_coverage_fout);
      ___coverage_array[3457] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3454] == 0) {
        {
        fprintf(_coverage_fout, "3454\n");
        fflush(_coverage_fout);
        ___coverage_array[3454] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3455] == 0) {
        {
        fprintf(_coverage_fout, "3455\n");
        fflush(_coverage_fout);
        ___coverage_array[3455] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3456] == 0) {
        {
        fprintf(_coverage_fout, "3456\n");
        fflush(_coverage_fout);
        ___coverage_array[3456] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3458] == 0) {
      {
      fprintf(_coverage_fout, "3458\n");
      fflush(_coverage_fout);
      ___coverage_array[3458] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3459] == 0) {
      {
      fprintf(_coverage_fout, "3459\n");
      fflush(_coverage_fout);
      ___coverage_array[3459] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3485] == 0) {
    {
    fprintf(_coverage_fout, "3485\n");
    fflush(_coverage_fout);
    ___coverage_array[3485] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3486] == 0) {
    {
    fprintf(_coverage_fout, "3486\n");
    fflush(_coverage_fout);
    ___coverage_array[3486] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3487] == 0) {
    {
    fprintf(_coverage_fout, "3487\n");
    fflush(_coverage_fout);
    ___coverage_array[3487] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3463] == 0) {
      {
      fprintf(_coverage_fout, "3463\n");
      fflush(_coverage_fout);
      ___coverage_array[3463] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3464] == 0) {
      {
      fprintf(_coverage_fout, "3464\n");
      fflush(_coverage_fout);
      ___coverage_array[3464] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3460] == 0) {
        {
        fprintf(_coverage_fout, "3460\n");
        fflush(_coverage_fout);
        ___coverage_array[3460] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3461] == 0) {
        {
        fprintf(_coverage_fout, "3461\n");
        fflush(_coverage_fout);
        ___coverage_array[3461] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3462] == 0) {
        {
        fprintf(_coverage_fout, "3462\n");
        fflush(_coverage_fout);
        ___coverage_array[3462] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3465] == 0) {
      {
      fprintf(_coverage_fout, "3465\n");
      fflush(_coverage_fout);
      ___coverage_array[3465] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3466] == 0) {
      {
      fprintf(_coverage_fout, "3466\n");
      fflush(_coverage_fout);
      ___coverage_array[3466] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3488] == 0) {
    {
    fprintf(_coverage_fout, "3488\n");
    fflush(_coverage_fout);
    ___coverage_array[3488] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((dateobj->time)->is_localtime) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3473] == 0) {
      {
      fprintf(_coverage_fout, "3473\n");
      fflush(_coverage_fout);
      ___coverage_array[3473] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_date_instantiate(date_ce_timezone, return_value);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3474] == 0) {
      {
      fprintf(_coverage_fout, "3474\n");
      fflush(_coverage_fout);
      ___coverage_array[3474] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = zend_object_store_get_object((zval const   *)return_value);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3475] == 0) {
      {
      fprintf(_coverage_fout, "3475\n");
      fflush(_coverage_fout);
      ___coverage_array[3475] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzobj = (php_timezone_obj *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3476] == 0) {
      {
      fprintf(_coverage_fout, "3476\n");
      fflush(_coverage_fout);
      ___coverage_array[3476] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzobj->initialized = 1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3477] == 0) {
      {
      fprintf(_coverage_fout, "3477\n");
      fflush(_coverage_fout);
      ___coverage_array[3477] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzobj->type = (int )(dateobj->time)->zone_type;
    switch ((int )(dateobj->time)->zone_type) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3467] == 0) {
      {
      fprintf(_coverage_fout, "3467\n");
      fflush(_coverage_fout);
      ___coverage_array[3467] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 3: 
    tzobj->tzi.tz = (dateobj->time)->tz_info;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3468] == 0) {
      {
      fprintf(_coverage_fout, "3468\n");
      fflush(_coverage_fout);
      ___coverage_array[3468] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 1: 
    tzobj->tzi.utc_offset = (long long )(dateobj->time)->z;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3469] == 0) {
      {
      fprintf(_coverage_fout, "3469\n");
      fflush(_coverage_fout);
      ___coverage_array[3469] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 2: 
    tzobj->tzi.z.utc_offset = (long long )(dateobj->time)->z;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3470] == 0) {
      {
      fprintf(_coverage_fout, "3470\n");
      fflush(_coverage_fout);
      ___coverage_array[3470] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzobj->tzi.z.dst = (dateobj->time)->dst;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3471] == 0) {
      {
      fprintf(_coverage_fout, "3471\n");
      fflush(_coverage_fout);
      ___coverage_array[3471] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = __strdup((char const   *)(dateobj->time)->tz_abbr);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3472] == 0) {
      {
      fprintf(_coverage_fout, "3472\n");
      fflush(_coverage_fout);
      ___coverage_array[3472] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzobj->tzi.z.abbr = tmp___7;
    break;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3481] == 0) {
      {
      fprintf(_coverage_fout, "3481\n");
      fflush(_coverage_fout);
      ___coverage_array[3481] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3478] == 0) {
        {
        fprintf(_coverage_fout, "3478\n");
        fflush(_coverage_fout);
        ___coverage_array[3478] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3479] == 0) {
        {
        fprintf(_coverage_fout, "3479\n");
        fflush(_coverage_fout);
        ___coverage_array[3479] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3480] == 0) {
        {
        fprintf(_coverage_fout, "3480\n");
        fflush(_coverage_fout);
        ___coverage_array[3480] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3482] == 0) {
      {
      fprintf(_coverage_fout, "3482\n");
      fflush(_coverage_fout);
      ___coverage_array[3482] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3489] == 0) {
    {
    fprintf(_coverage_fout, "3489\n");
    fflush(_coverage_fout);
    ___coverage_array[3489] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_timezone_set(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) 
{ zval *object ;
  zval *timezone_object ;
  php_date_obj *dateobj ;
  php_timezone_obj *tzobj ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_uchar is_ref ;
  zend_bool tmp___2 ;
  zend_uint refcount ;
  zend_uint tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3508] == 0) {
    {
    fprintf(_coverage_fout, "3508\n");
    fflush(_coverage_fout);
    ___coverage_array[3508] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "OO", & object, date_ce_date,
                                     & timezone_object, date_ce_timezone);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3509] == 0) {
    {
    fprintf(_coverage_fout, "3509\n");
    fflush(_coverage_fout);
    ___coverage_array[3509] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3493] == 0) {
      {
      fprintf(_coverage_fout, "3493\n");
      fflush(_coverage_fout);
      ___coverage_array[3493] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3490] == 0) {
        {
        fprintf(_coverage_fout, "3490\n");
        fflush(_coverage_fout);
        ___coverage_array[3490] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3491] == 0) {
        {
        fprintf(_coverage_fout, "3491\n");
        fflush(_coverage_fout);
        ___coverage_array[3491] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3492] == 0) {
        {
        fprintf(_coverage_fout, "3492\n");
        fflush(_coverage_fout);
        ___coverage_array[3492] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3494] == 0) {
      {
      fprintf(_coverage_fout, "3494\n");
      fflush(_coverage_fout);
      ___coverage_array[3494] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3495] == 0) {
      {
      fprintf(_coverage_fout, "3495\n");
      fflush(_coverage_fout);
      ___coverage_array[3495] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3510] == 0) {
    {
    fprintf(_coverage_fout, "3510\n");
    fflush(_coverage_fout);
    ___coverage_array[3510] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3511] == 0) {
    {
    fprintf(_coverage_fout, "3511\n");
    fflush(_coverage_fout);
    ___coverage_array[3511] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3512] == 0) {
    {
    fprintf(_coverage_fout, "3512\n");
    fflush(_coverage_fout);
    ___coverage_array[3512] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3499] == 0) {
      {
      fprintf(_coverage_fout, "3499\n");
      fflush(_coverage_fout);
      ___coverage_array[3499] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3500] == 0) {
      {
      fprintf(_coverage_fout, "3500\n");
      fflush(_coverage_fout);
      ___coverage_array[3500] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3496] == 0) {
        {
        fprintf(_coverage_fout, "3496\n");
        fflush(_coverage_fout);
        ___coverage_array[3496] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3497] == 0) {
        {
        fprintf(_coverage_fout, "3497\n");
        fflush(_coverage_fout);
        ___coverage_array[3497] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3498] == 0) {
        {
        fprintf(_coverage_fout, "3498\n");
        fflush(_coverage_fout);
        ___coverage_array[3498] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3501] == 0) {
      {
      fprintf(_coverage_fout, "3501\n");
      fflush(_coverage_fout);
      ___coverage_array[3501] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3502] == 0) {
      {
      fprintf(_coverage_fout, "3502\n");
      fflush(_coverage_fout);
      ___coverage_array[3502] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3513] == 0) {
    {
    fprintf(_coverage_fout, "3513\n");
    fflush(_coverage_fout);
    ___coverage_array[3513] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)timezone_object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3514] == 0) {
    {
    fprintf(_coverage_fout, "3514\n");
    fflush(_coverage_fout);
    ___coverage_array[3514] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj = (php_timezone_obj *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3515] == 0) {
    {
    fprintf(_coverage_fout, "3515\n");
    fflush(_coverage_fout);
    ___coverage_array[3515] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tzobj->type != 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3503] == 0) {
      {
      fprintf(_coverage_fout, "3503\n");
      fflush(_coverage_fout);
      ___coverage_array[3503] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Can only do this for zones with ID for now");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3504] == 0) {
      {
      fprintf(_coverage_fout, "3504\n");
      fflush(_coverage_fout);
      ___coverage_array[3504] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3505] == 0) {
      {
      fprintf(_coverage_fout, "3505\n");
      fflush(_coverage_fout);
      ___coverage_array[3505] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3516] == 0) {
    {
    fprintf(_coverage_fout, "3516\n");
    fflush(_coverage_fout);
    ___coverage_array[3516] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_set_timezone(dateobj->time, tzobj->tzi.tz);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3517] == 0) {
    {
    fprintf(_coverage_fout, "3517\n");
    fflush(_coverage_fout);
    ___coverage_array[3517] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(dateobj->time, (dateobj->time)->sse);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3518] == 0) {
    {
    fprintf(_coverage_fout, "3518\n");
    fflush(_coverage_fout);
    ___coverage_array[3518] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3519] == 0) {
    {
    fprintf(_coverage_fout, "3519\n");
    fflush(_coverage_fout);
    ___coverage_array[3519] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3520] == 0) {
    {
    fprintf(_coverage_fout, "3520\n");
    fflush(_coverage_fout);
    ___coverage_array[3520] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3521] == 0) {
    {
    fprintf(_coverage_fout, "3521\n");
    fflush(_coverage_fout);
    ___coverage_array[3521] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3522] == 0) {
    {
    fprintf(_coverage_fout, "3522\n");
    fflush(_coverage_fout);
    ___coverage_array[3522] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3506] == 0) {
      {
      fprintf(_coverage_fout, "3506\n");
      fflush(_coverage_fout);
      ___coverage_array[3506] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3507] == 0) {
      {
      fprintf(_coverage_fout, "3507\n");
      fflush(_coverage_fout);
      ___coverage_array[3507] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3523] == 0) {
    {
    fprintf(_coverage_fout, "3523\n");
    fflush(_coverage_fout);
    ___coverage_array[3523] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3524] == 0) {
    {
    fprintf(_coverage_fout, "3524\n");
    fflush(_coverage_fout);
    ___coverage_array[3524] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3525] == 0) {
    {
    fprintf(_coverage_fout, "3525\n");
    fflush(_coverage_fout);
    ___coverage_array[3525] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3526] == 0) {
    {
    fprintf(_coverage_fout, "3526\n");
    fflush(_coverage_fout);
    ___coverage_array[3526] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_offset_get(int ht , zval *return_value , zval **return_value_ptr ,
                         zval *this_ptr , int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  timelib_time_offset *offset ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval *__z___2 ;
  zval *__z___3 ;
  zval *__z___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3556] == 0) {
    {
    fprintf(_coverage_fout, "3556\n");
    fflush(_coverage_fout);
    ___coverage_array[3556] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & object, date_ce_date);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3557] == 0) {
    {
    fprintf(_coverage_fout, "3557\n");
    fflush(_coverage_fout);
    ___coverage_array[3557] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3530] == 0) {
      {
      fprintf(_coverage_fout, "3530\n");
      fflush(_coverage_fout);
      ___coverage_array[3530] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3527] == 0) {
        {
        fprintf(_coverage_fout, "3527\n");
        fflush(_coverage_fout);
        ___coverage_array[3527] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3528] == 0) {
        {
        fprintf(_coverage_fout, "3528\n");
        fflush(_coverage_fout);
        ___coverage_array[3528] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3529] == 0) {
        {
        fprintf(_coverage_fout, "3529\n");
        fflush(_coverage_fout);
        ___coverage_array[3529] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3531] == 0) {
      {
      fprintf(_coverage_fout, "3531\n");
      fflush(_coverage_fout);
      ___coverage_array[3531] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3532] == 0) {
      {
      fprintf(_coverage_fout, "3532\n");
      fflush(_coverage_fout);
      ___coverage_array[3532] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3558] == 0) {
    {
    fprintf(_coverage_fout, "3558\n");
    fflush(_coverage_fout);
    ___coverage_array[3558] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3559] == 0) {
    {
    fprintf(_coverage_fout, "3559\n");
    fflush(_coverage_fout);
    ___coverage_array[3559] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3560] == 0) {
    {
    fprintf(_coverage_fout, "3560\n");
    fflush(_coverage_fout);
    ___coverage_array[3560] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3536] == 0) {
      {
      fprintf(_coverage_fout, "3536\n");
      fflush(_coverage_fout);
      ___coverage_array[3536] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3537] == 0) {
      {
      fprintf(_coverage_fout, "3537\n");
      fflush(_coverage_fout);
      ___coverage_array[3537] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3533] == 0) {
        {
        fprintf(_coverage_fout, "3533\n");
        fflush(_coverage_fout);
        ___coverage_array[3533] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3534] == 0) {
        {
        fprintf(_coverage_fout, "3534\n");
        fflush(_coverage_fout);
        ___coverage_array[3534] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3535] == 0) {
        {
        fprintf(_coverage_fout, "3535\n");
        fflush(_coverage_fout);
        ___coverage_array[3535] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3538] == 0) {
      {
      fprintf(_coverage_fout, "3538\n");
      fflush(_coverage_fout);
      ___coverage_array[3538] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3539] == 0) {
      {
      fprintf(_coverage_fout, "3539\n");
      fflush(_coverage_fout);
      ___coverage_array[3539] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3561] == 0) {
    {
    fprintf(_coverage_fout, "3561\n");
    fflush(_coverage_fout);
    ___coverage_array[3561] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((dateobj->time)->is_localtime) {
    switch ((int )(dateobj->time)->zone_type) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3540] == 0) {
      {
      fprintf(_coverage_fout, "3540\n");
      fflush(_coverage_fout);
      ___coverage_array[3540] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 3: 
    offset = timelib_get_time_zone_info((dateobj->time)->sse,
                                        (dateobj->time)->tz_info);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3541] == 0) {
      {
      fprintf(_coverage_fout, "3541\n");
      fflush(_coverage_fout);
      ___coverage_array[3541] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3542] == 0) {
      {
      fprintf(_coverage_fout, "3542\n");
      fflush(_coverage_fout);
      ___coverage_array[3542] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.lval = (long )offset->offset;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3543] == 0) {
      {
      fprintf(_coverage_fout, "3543\n");
      fflush(_coverage_fout);
      ___coverage_array[3543] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3544] == 0) {
      {
      fprintf(_coverage_fout, "3544\n");
      fflush(_coverage_fout);
      ___coverage_array[3544] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    timelib_time_offset_dtor(offset);
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3545] == 0) {
      {
      fprintf(_coverage_fout, "3545\n");
      fflush(_coverage_fout);
      ___coverage_array[3545] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 1: 
    __z___2 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3546] == 0) {
      {
      fprintf(_coverage_fout, "3546\n");
      fflush(_coverage_fout);
      ___coverage_array[3546] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->value.lval = (long )((dateobj->time)->z * -60);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3547] == 0) {
      {
      fprintf(_coverage_fout, "3547\n");
      fflush(_coverage_fout);
      ___coverage_array[3547] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->type = (unsigned char)1;
    break;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3548] == 0) {
      {
      fprintf(_coverage_fout, "3548\n");
      fflush(_coverage_fout);
      ___coverage_array[3548] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    case 2: 
    __z___3 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3549] == 0) {
      {
      fprintf(_coverage_fout, "3549\n");
      fflush(_coverage_fout);
      ___coverage_array[3549] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3->value.lval = (long )(((dateobj->time)->z - 60 * (dateobj->time)->dst) * -60);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3550] == 0) {
      {
      fprintf(_coverage_fout, "3550\n");
      fflush(_coverage_fout);
      ___coverage_array[3550] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3->type = (unsigned char)1;
    break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3551] == 0) {
      {
      fprintf(_coverage_fout, "3551\n");
      fflush(_coverage_fout);
      ___coverage_array[3551] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3552] == 0) {
      {
      fprintf(_coverage_fout, "3552\n");
      fflush(_coverage_fout);
      ___coverage_array[3552] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3553] == 0) {
      {
      fprintf(_coverage_fout, "3553\n");
      fflush(_coverage_fout);
      ___coverage_array[3553] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4->value.lval = 0L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3554] == 0) {
      {
      fprintf(_coverage_fout, "3554\n");
      fflush(_coverage_fout);
      ___coverage_array[3554] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4->type = (unsigned char)1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3555] == 0) {
      {
      fprintf(_coverage_fout, "3555\n");
      fflush(_coverage_fout);
      ___coverage_array[3555] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
}
}
void zif_date_time_set(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  long h ;
  long i ;
  long s ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zend_uchar is_ref ;
  zend_bool tmp___1 ;
  zend_uint refcount ;
  zend_uint tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3577] == 0) {
    {
    fprintf(_coverage_fout, "3577\n");
    fflush(_coverage_fout);
    ___coverage_array[3577] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  s = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3578] == 0) {
    {
    fprintf(_coverage_fout, "3578\n");
    fflush(_coverage_fout);
    ___coverage_array[3578] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Oll|l", & object,
                                     date_ce_date, & h, & i, & s);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3579] == 0) {
    {
    fprintf(_coverage_fout, "3579\n");
    fflush(_coverage_fout);
    ___coverage_array[3579] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3565] == 0) {
      {
      fprintf(_coverage_fout, "3565\n");
      fflush(_coverage_fout);
      ___coverage_array[3565] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3562] == 0) {
        {
        fprintf(_coverage_fout, "3562\n");
        fflush(_coverage_fout);
        ___coverage_array[3562] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3563] == 0) {
        {
        fprintf(_coverage_fout, "3563\n");
        fflush(_coverage_fout);
        ___coverage_array[3563] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3564] == 0) {
        {
        fprintf(_coverage_fout, "3564\n");
        fflush(_coverage_fout);
        ___coverage_array[3564] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3566] == 0) {
      {
      fprintf(_coverage_fout, "3566\n");
      fflush(_coverage_fout);
      ___coverage_array[3566] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3567] == 0) {
      {
      fprintf(_coverage_fout, "3567\n");
      fflush(_coverage_fout);
      ___coverage_array[3567] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3580] == 0) {
    {
    fprintf(_coverage_fout, "3580\n");
    fflush(_coverage_fout);
    ___coverage_array[3580] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3581] == 0) {
    {
    fprintf(_coverage_fout, "3581\n");
    fflush(_coverage_fout);
    ___coverage_array[3581] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3582] == 0) {
    {
    fprintf(_coverage_fout, "3582\n");
    fflush(_coverage_fout);
    ___coverage_array[3582] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3571] == 0) {
      {
      fprintf(_coverage_fout, "3571\n");
      fflush(_coverage_fout);
      ___coverage_array[3571] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3572] == 0) {
      {
      fprintf(_coverage_fout, "3572\n");
      fflush(_coverage_fout);
      ___coverage_array[3572] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3568] == 0) {
        {
        fprintf(_coverage_fout, "3568\n");
        fflush(_coverage_fout);
        ___coverage_array[3568] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3569] == 0) {
        {
        fprintf(_coverage_fout, "3569\n");
        fflush(_coverage_fout);
        ___coverage_array[3569] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3570] == 0) {
        {
        fprintf(_coverage_fout, "3570\n");
        fflush(_coverage_fout);
        ___coverage_array[3570] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3573] == 0) {
      {
      fprintf(_coverage_fout, "3573\n");
      fflush(_coverage_fout);
      ___coverage_array[3573] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3574] == 0) {
      {
      fprintf(_coverage_fout, "3574\n");
      fflush(_coverage_fout);
      ___coverage_array[3574] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3583] == 0) {
    {
    fprintf(_coverage_fout, "3583\n");
    fflush(_coverage_fout);
    ___coverage_array[3583] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->h = (long long )h;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3584] == 0) {
    {
    fprintf(_coverage_fout, "3584\n");
    fflush(_coverage_fout);
    ___coverage_array[3584] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->i = (long long )i;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3585] == 0) {
    {
    fprintf(_coverage_fout, "3585\n");
    fflush(_coverage_fout);
    ___coverage_array[3585] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->s = (long long )s;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3586] == 0) {
    {
    fprintf(_coverage_fout, "3586\n");
    fflush(_coverage_fout);
    ___coverage_array[3586] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3587] == 0) {
    {
    fprintf(_coverage_fout, "3587\n");
    fflush(_coverage_fout);
    ___coverage_array[3587] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3588] == 0) {
    {
    fprintf(_coverage_fout, "3588\n");
    fflush(_coverage_fout);
    ___coverage_array[3588] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3589] == 0) {
    {
    fprintf(_coverage_fout, "3589\n");
    fflush(_coverage_fout);
    ___coverage_array[3589] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3590] == 0) {
    {
    fprintf(_coverage_fout, "3590\n");
    fflush(_coverage_fout);
    ___coverage_array[3590] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3591] == 0) {
    {
    fprintf(_coverage_fout, "3591\n");
    fflush(_coverage_fout);
    ___coverage_array[3591] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3575] == 0) {
      {
      fprintf(_coverage_fout, "3575\n");
      fflush(_coverage_fout);
      ___coverage_array[3575] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3576] == 0) {
      {
      fprintf(_coverage_fout, "3576\n");
      fflush(_coverage_fout);
      ___coverage_array[3576] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3592] == 0) {
    {
    fprintf(_coverage_fout, "3592\n");
    fflush(_coverage_fout);
    ___coverage_array[3592] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3593] == 0) {
    {
    fprintf(_coverage_fout, "3593\n");
    fflush(_coverage_fout);
    ___coverage_array[3593] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3594] == 0) {
    {
    fprintf(_coverage_fout, "3594\n");
    fflush(_coverage_fout);
    ___coverage_array[3594] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3595] == 0) {
    {
    fprintf(_coverage_fout, "3595\n");
    fflush(_coverage_fout);
    ___coverage_array[3595] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_date_set(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  long y ;
  long m ;
  long d ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zend_uchar is_ref ;
  zend_bool tmp___1 ;
  zend_uint refcount ;
  zend_uint tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3611] == 0) {
    {
    fprintf(_coverage_fout, "3611\n");
    fflush(_coverage_fout);
    ___coverage_array[3611] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Olll", & object,
                                     date_ce_date, & y, & m, & d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3612] == 0) {
    {
    fprintf(_coverage_fout, "3612\n");
    fflush(_coverage_fout);
    ___coverage_array[3612] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3599] == 0) {
      {
      fprintf(_coverage_fout, "3599\n");
      fflush(_coverage_fout);
      ___coverage_array[3599] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3596] == 0) {
        {
        fprintf(_coverage_fout, "3596\n");
        fflush(_coverage_fout);
        ___coverage_array[3596] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3597] == 0) {
        {
        fprintf(_coverage_fout, "3597\n");
        fflush(_coverage_fout);
        ___coverage_array[3597] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3598] == 0) {
        {
        fprintf(_coverage_fout, "3598\n");
        fflush(_coverage_fout);
        ___coverage_array[3598] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3600] == 0) {
      {
      fprintf(_coverage_fout, "3600\n");
      fflush(_coverage_fout);
      ___coverage_array[3600] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3601] == 0) {
      {
      fprintf(_coverage_fout, "3601\n");
      fflush(_coverage_fout);
      ___coverage_array[3601] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3613] == 0) {
    {
    fprintf(_coverage_fout, "3613\n");
    fflush(_coverage_fout);
    ___coverage_array[3613] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3614] == 0) {
    {
    fprintf(_coverage_fout, "3614\n");
    fflush(_coverage_fout);
    ___coverage_array[3614] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3615] == 0) {
    {
    fprintf(_coverage_fout, "3615\n");
    fflush(_coverage_fout);
    ___coverage_array[3615] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3605] == 0) {
      {
      fprintf(_coverage_fout, "3605\n");
      fflush(_coverage_fout);
      ___coverage_array[3605] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3606] == 0) {
      {
      fprintf(_coverage_fout, "3606\n");
      fflush(_coverage_fout);
      ___coverage_array[3606] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3602] == 0) {
        {
        fprintf(_coverage_fout, "3602\n");
        fflush(_coverage_fout);
        ___coverage_array[3602] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3603] == 0) {
        {
        fprintf(_coverage_fout, "3603\n");
        fflush(_coverage_fout);
        ___coverage_array[3603] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3604] == 0) {
        {
        fprintf(_coverage_fout, "3604\n");
        fflush(_coverage_fout);
        ___coverage_array[3604] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3607] == 0) {
      {
      fprintf(_coverage_fout, "3607\n");
      fflush(_coverage_fout);
      ___coverage_array[3607] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3608] == 0) {
      {
      fprintf(_coverage_fout, "3608\n");
      fflush(_coverage_fout);
      ___coverage_array[3608] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3616] == 0) {
    {
    fprintf(_coverage_fout, "3616\n");
    fflush(_coverage_fout);
    ___coverage_array[3616] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->y = (long long )y;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3617] == 0) {
    {
    fprintf(_coverage_fout, "3617\n");
    fflush(_coverage_fout);
    ___coverage_array[3617] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->m = (long long )m;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3618] == 0) {
    {
    fprintf(_coverage_fout, "3618\n");
    fflush(_coverage_fout);
    ___coverage_array[3618] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->d = (long long )d;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3619] == 0) {
    {
    fprintf(_coverage_fout, "3619\n");
    fflush(_coverage_fout);
    ___coverage_array[3619] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3620] == 0) {
    {
    fprintf(_coverage_fout, "3620\n");
    fflush(_coverage_fout);
    ___coverage_array[3620] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3621] == 0) {
    {
    fprintf(_coverage_fout, "3621\n");
    fflush(_coverage_fout);
    ___coverage_array[3621] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3622] == 0) {
    {
    fprintf(_coverage_fout, "3622\n");
    fflush(_coverage_fout);
    ___coverage_array[3622] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3623] == 0) {
    {
    fprintf(_coverage_fout, "3623\n");
    fflush(_coverage_fout);
    ___coverage_array[3623] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3624] == 0) {
    {
    fprintf(_coverage_fout, "3624\n");
    fflush(_coverage_fout);
    ___coverage_array[3624] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3609] == 0) {
      {
      fprintf(_coverage_fout, "3609\n");
      fflush(_coverage_fout);
      ___coverage_array[3609] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3610] == 0) {
      {
      fprintf(_coverage_fout, "3610\n");
      fflush(_coverage_fout);
      ___coverage_array[3610] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3625] == 0) {
    {
    fprintf(_coverage_fout, "3625\n");
    fflush(_coverage_fout);
    ___coverage_array[3625] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3626] == 0) {
    {
    fprintf(_coverage_fout, "3626\n");
    fflush(_coverage_fout);
    ___coverage_array[3626] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3627] == 0) {
    {
    fprintf(_coverage_fout, "3627\n");
    fflush(_coverage_fout);
    ___coverage_array[3627] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3628] == 0) {
    {
    fprintf(_coverage_fout, "3628\n");
    fflush(_coverage_fout);
    ___coverage_array[3628] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_isodate_set(int ht , zval *return_value ,
                          zval **return_value_ptr , zval *this_ptr ,
                          int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  long y ;
  long w ;
  long d ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zend_uchar is_ref ;
  zend_bool tmp___1 ;
  zend_uint refcount ;
  zend_uint tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3644] == 0) {
    {
    fprintf(_coverage_fout, "3644\n");
    fflush(_coverage_fout);
    ___coverage_array[3644] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  d = 1L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3645] == 0) {
    {
    fprintf(_coverage_fout, "3645\n");
    fflush(_coverage_fout);
    ___coverage_array[3645] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Oll|l", & object,
                                     date_ce_date, & y, & w, & d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3646] == 0) {
    {
    fprintf(_coverage_fout, "3646\n");
    fflush(_coverage_fout);
    ___coverage_array[3646] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3632] == 0) {
      {
      fprintf(_coverage_fout, "3632\n");
      fflush(_coverage_fout);
      ___coverage_array[3632] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3629] == 0) {
        {
        fprintf(_coverage_fout, "3629\n");
        fflush(_coverage_fout);
        ___coverage_array[3629] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3630] == 0) {
        {
        fprintf(_coverage_fout, "3630\n");
        fflush(_coverage_fout);
        ___coverage_array[3630] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3631] == 0) {
        {
        fprintf(_coverage_fout, "3631\n");
        fflush(_coverage_fout);
        ___coverage_array[3631] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3633] == 0) {
      {
      fprintf(_coverage_fout, "3633\n");
      fflush(_coverage_fout);
      ___coverage_array[3633] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3634] == 0) {
      {
      fprintf(_coverage_fout, "3634\n");
      fflush(_coverage_fout);
      ___coverage_array[3634] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3647] == 0) {
    {
    fprintf(_coverage_fout, "3647\n");
    fflush(_coverage_fout);
    ___coverage_array[3647] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3648] == 0) {
    {
    fprintf(_coverage_fout, "3648\n");
    fflush(_coverage_fout);
    ___coverage_array[3648] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3649] == 0) {
    {
    fprintf(_coverage_fout, "3649\n");
    fflush(_coverage_fout);
    ___coverage_array[3649] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3638] == 0) {
      {
      fprintf(_coverage_fout, "3638\n");
      fflush(_coverage_fout);
      ___coverage_array[3638] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3639] == 0) {
      {
      fprintf(_coverage_fout, "3639\n");
      fflush(_coverage_fout);
      ___coverage_array[3639] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3635] == 0) {
        {
        fprintf(_coverage_fout, "3635\n");
        fflush(_coverage_fout);
        ___coverage_array[3635] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3636] == 0) {
        {
        fprintf(_coverage_fout, "3636\n");
        fflush(_coverage_fout);
        ___coverage_array[3636] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3637] == 0) {
        {
        fprintf(_coverage_fout, "3637\n");
        fflush(_coverage_fout);
        ___coverage_array[3637] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3640] == 0) {
      {
      fprintf(_coverage_fout, "3640\n");
      fflush(_coverage_fout);
      ___coverage_array[3640] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3641] == 0) {
      {
      fprintf(_coverage_fout, "3641\n");
      fflush(_coverage_fout);
      ___coverage_array[3641] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3650] == 0) {
    {
    fprintf(_coverage_fout, "3650\n");
    fflush(_coverage_fout);
    ___coverage_array[3650] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->y = (long long )y;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3651] == 0) {
    {
    fprintf(_coverage_fout, "3651\n");
    fflush(_coverage_fout);
    ___coverage_array[3651] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->m = 1LL;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3652] == 0) {
    {
    fprintf(_coverage_fout, "3652\n");
    fflush(_coverage_fout);
    ___coverage_array[3652] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->d = 1LL;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3653] == 0) {
    {
    fprintf(_coverage_fout, "3653\n");
    fflush(_coverage_fout);
    ___coverage_array[3653] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  memset((void *)(& (dateobj->time)->relative), 0,
         sizeof((dateobj->time)->relative));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3654] == 0) {
    {
    fprintf(_coverage_fout, "3654\n");
    fflush(_coverage_fout);
    ___coverage_array[3654] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->relative.d = timelib_daynr_from_weeknr((long long )y,
                                                          (long long )w,
                                                          (long long )d);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3655] == 0) {
    {
    fprintf(_coverage_fout, "3655\n");
    fflush(_coverage_fout);
    ___coverage_array[3655] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  (dateobj->time)->have_relative = 1U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3656] == 0) {
    {
    fprintf(_coverage_fout, "3656\n");
    fflush(_coverage_fout);
    ___coverage_array[3656] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3657] == 0) {
    {
    fprintf(_coverage_fout, "3657\n");
    fflush(_coverage_fout);
    ___coverage_array[3657] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3658] == 0) {
    {
    fprintf(_coverage_fout, "3658\n");
    fflush(_coverage_fout);
    ___coverage_array[3658] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3659] == 0) {
    {
    fprintf(_coverage_fout, "3659\n");
    fflush(_coverage_fout);
    ___coverage_array[3659] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3660] == 0) {
    {
    fprintf(_coverage_fout, "3660\n");
    fflush(_coverage_fout);
    ___coverage_array[3660] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3661] == 0) {
    {
    fprintf(_coverage_fout, "3661\n");
    fflush(_coverage_fout);
    ___coverage_array[3661] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3642] == 0) {
      {
      fprintf(_coverage_fout, "3642\n");
      fflush(_coverage_fout);
      ___coverage_array[3642] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3643] == 0) {
      {
      fprintf(_coverage_fout, "3643\n");
      fflush(_coverage_fout);
      ___coverage_array[3643] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3662] == 0) {
    {
    fprintf(_coverage_fout, "3662\n");
    fflush(_coverage_fout);
    ___coverage_array[3662] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3663] == 0) {
    {
    fprintf(_coverage_fout, "3663\n");
    fflush(_coverage_fout);
    ___coverage_array[3663] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3664] == 0) {
    {
    fprintf(_coverage_fout, "3664\n");
    fflush(_coverage_fout);
    ___coverage_array[3664] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3665] == 0) {
    {
    fprintf(_coverage_fout, "3665\n");
    fflush(_coverage_fout);
    ___coverage_array[3665] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_timestamp_set(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  long timestamp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zend_uchar is_ref ;
  zend_bool tmp___1 ;
  zend_uint refcount ;
  zend_uint tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3681] == 0) {
    {
    fprintf(_coverage_fout, "3681\n");
    fflush(_coverage_fout);
    ___coverage_array[3681] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "Ol", & object, date_ce_date,
                                     & timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3682] == 0) {
    {
    fprintf(_coverage_fout, "3682\n");
    fflush(_coverage_fout);
    ___coverage_array[3682] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3669] == 0) {
      {
      fprintf(_coverage_fout, "3669\n");
      fflush(_coverage_fout);
      ___coverage_array[3669] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3666] == 0) {
        {
        fprintf(_coverage_fout, "3666\n");
        fflush(_coverage_fout);
        ___coverage_array[3666] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3667] == 0) {
        {
        fprintf(_coverage_fout, "3667\n");
        fflush(_coverage_fout);
        ___coverage_array[3667] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3668] == 0) {
        {
        fprintf(_coverage_fout, "3668\n");
        fflush(_coverage_fout);
        ___coverage_array[3668] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3670] == 0) {
      {
      fprintf(_coverage_fout, "3670\n");
      fflush(_coverage_fout);
      ___coverage_array[3670] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3671] == 0) {
      {
      fprintf(_coverage_fout, "3671\n");
      fflush(_coverage_fout);
      ___coverage_array[3671] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3683] == 0) {
    {
    fprintf(_coverage_fout, "3683\n");
    fflush(_coverage_fout);
    ___coverage_array[3683] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3684] == 0) {
    {
    fprintf(_coverage_fout, "3684\n");
    fflush(_coverage_fout);
    ___coverage_array[3684] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3685] == 0) {
    {
    fprintf(_coverage_fout, "3685\n");
    fflush(_coverage_fout);
    ___coverage_array[3685] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3675] == 0) {
      {
      fprintf(_coverage_fout, "3675\n");
      fflush(_coverage_fout);
      ___coverage_array[3675] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3676] == 0) {
      {
      fprintf(_coverage_fout, "3676\n");
      fflush(_coverage_fout);
      ___coverage_array[3676] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3672] == 0) {
        {
        fprintf(_coverage_fout, "3672\n");
        fflush(_coverage_fout);
        ___coverage_array[3672] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3673] == 0) {
        {
        fprintf(_coverage_fout, "3673\n");
        fflush(_coverage_fout);
        ___coverage_array[3673] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3674] == 0) {
        {
        fprintf(_coverage_fout, "3674\n");
        fflush(_coverage_fout);
        ___coverage_array[3674] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3677] == 0) {
      {
      fprintf(_coverage_fout, "3677\n");
      fflush(_coverage_fout);
      ___coverage_array[3677] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3678] == 0) {
      {
      fprintf(_coverage_fout, "3678\n");
      fflush(_coverage_fout);
      ___coverage_array[3678] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3686] == 0) {
    {
    fprintf(_coverage_fout, "3686\n");
    fflush(_coverage_fout);
    ___coverage_array[3686] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(dateobj->time, (long long )timestamp);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3687] == 0) {
    {
    fprintf(_coverage_fout, "3687\n");
    fflush(_coverage_fout);
    ___coverage_array[3687] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3688] == 0) {
    {
    fprintf(_coverage_fout, "3688\n");
    fflush(_coverage_fout);
    ___coverage_array[3688] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zval_isref_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3689] == 0) {
    {
    fprintf(_coverage_fout, "3689\n");
    fflush(_coverage_fout);
    ___coverage_array[3689] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  is_ref = tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3690] == 0) {
    {
    fprintf(_coverage_fout, "3690\n");
    fflush(_coverage_fout);
    ___coverage_array[3690] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zval_refcount_p(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3691] == 0) {
    {
    fprintf(_coverage_fout, "3691\n");
    fflush(_coverage_fout);
    ___coverage_array[3691] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  refcount = tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3692] == 0) {
    {
    fprintf(_coverage_fout, "3692\n");
    fflush(_coverage_fout);
    ___coverage_array[3692] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3679] == 0) {
      {
      fprintf(_coverage_fout, "3679\n");
      fflush(_coverage_fout);
      ___coverage_array[3679] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->value = object->value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3680] == 0) {
      {
      fprintf(_coverage_fout, "3680\n");
      fflush(_coverage_fout);
      ___coverage_array[3680] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return_value->type = object->type;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3693] == 0) {
    {
    fprintf(_coverage_fout, "3693\n");
    fflush(_coverage_fout);
    ___coverage_array[3693] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _zval_copy_ctor(return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3694] == 0) {
    {
    fprintf(_coverage_fout, "3694\n");
    fflush(_coverage_fout);
    ___coverage_array[3694] = 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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3695] == 0) {
    {
    fprintf(_coverage_fout, "3695\n");
    fflush(_coverage_fout);
    ___coverage_array[3695] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(return_value, refcount);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3696] == 0) {
    {
    fprintf(_coverage_fout, "3696\n");
    fflush(_coverage_fout);
    ___coverage_array[3696] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_timestamp_get(int ht , zval *return_value ,
                            zval **return_value_ptr , zval *this_ptr ,
                            int return_value_used ) 
{ zval *object ;
  php_date_obj *dateobj ;
  long timestamp ;
  int error ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  zval *__z___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3718] == 0) {
    {
    fprintf(_coverage_fout, "3718\n");
    fflush(_coverage_fout);
    ___coverage_array[3718] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & object, date_ce_date);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3719] == 0) {
    {
    fprintf(_coverage_fout, "3719\n");
    fflush(_coverage_fout);
    ___coverage_array[3719] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3700] == 0) {
      {
      fprintf(_coverage_fout, "3700\n");
      fflush(_coverage_fout);
      ___coverage_array[3700] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3697] == 0) {
        {
        fprintf(_coverage_fout, "3697\n");
        fflush(_coverage_fout);
        ___coverage_array[3697] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3698] == 0) {
        {
        fprintf(_coverage_fout, "3698\n");
        fflush(_coverage_fout);
        ___coverage_array[3698] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3699] == 0) {
        {
        fprintf(_coverage_fout, "3699\n");
        fflush(_coverage_fout);
        ___coverage_array[3699] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3701] == 0) {
      {
      fprintf(_coverage_fout, "3701\n");
      fflush(_coverage_fout);
      ___coverage_array[3701] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3702] == 0) {
      {
      fprintf(_coverage_fout, "3702\n");
      fflush(_coverage_fout);
      ___coverage_array[3702] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3720] == 0) {
    {
    fprintf(_coverage_fout, "3720\n");
    fflush(_coverage_fout);
    ___coverage_array[3720] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3721] == 0) {
    {
    fprintf(_coverage_fout, "3721\n");
    fflush(_coverage_fout);
    ___coverage_array[3721] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3722] == 0) {
    {
    fprintf(_coverage_fout, "3722\n");
    fflush(_coverage_fout);
    ___coverage_array[3722] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3706] == 0) {
      {
      fprintf(_coverage_fout, "3706\n");
      fflush(_coverage_fout);
      ___coverage_array[3706] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3707] == 0) {
      {
      fprintf(_coverage_fout, "3707\n");
      fflush(_coverage_fout);
      ___coverage_array[3707] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3703] == 0) {
        {
        fprintf(_coverage_fout, "3703\n");
        fflush(_coverage_fout);
        ___coverage_array[3703] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3704] == 0) {
        {
        fprintf(_coverage_fout, "3704\n");
        fflush(_coverage_fout);
        ___coverage_array[3704] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3705] == 0) {
        {
        fprintf(_coverage_fout, "3705\n");
        fflush(_coverage_fout);
        ___coverage_array[3705] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3708] == 0) {
      {
      fprintf(_coverage_fout, "3708\n");
      fflush(_coverage_fout);
      ___coverage_array[3708] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3709] == 0) {
      {
      fprintf(_coverage_fout, "3709\n");
      fflush(_coverage_fout);
      ___coverage_array[3709] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3723] == 0) {
    {
    fprintf(_coverage_fout, "3723\n");
    fflush(_coverage_fout);
    ___coverage_array[3723] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3724] == 0) {
    {
    fprintf(_coverage_fout, "3724\n");
    fflush(_coverage_fout);
    ___coverage_array[3724] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp = timelib_date_to_int(dateobj->time, & error);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3725] == 0) {
    {
    fprintf(_coverage_fout, "3725\n");
    fflush(_coverage_fout);
    ___coverage_array[3725] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (error) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3713] == 0) {
      {
      fprintf(_coverage_fout, "3713\n");
      fflush(_coverage_fout);
      ___coverage_array[3713] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3710] == 0) {
        {
        fprintf(_coverage_fout, "3710\n");
        fflush(_coverage_fout);
        ___coverage_array[3710] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3711] == 0) {
        {
        fprintf(_coverage_fout, "3711\n");
        fflush(_coverage_fout);
        ___coverage_array[3711] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3712] == 0) {
        {
        fprintf(_coverage_fout, "3712\n");
        fflush(_coverage_fout);
        ___coverage_array[3712] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3714] == 0) {
      {
      fprintf(_coverage_fout, "3714\n");
      fflush(_coverage_fout);
      ___coverage_array[3714] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3715] == 0) {
      {
      fprintf(_coverage_fout, "3715\n");
      fflush(_coverage_fout);
      ___coverage_array[3715] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3716] == 0) {
      {
      fprintf(_coverage_fout, "3716\n");
      fflush(_coverage_fout);
      ___coverage_array[3716] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->value.lval = timestamp;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3717] == 0) {
      {
      fprintf(_coverage_fout, "3717\n");
      fflush(_coverage_fout);
      ___coverage_array[3717] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->type = (unsigned char)1;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3726] == 0) {
    {
    fprintf(_coverage_fout, "3726\n");
    fflush(_coverage_fout);
    ___coverage_array[3726] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_diff(int ht , zval *return_value , zval **return_value_ptr ,
                   zval *this_ptr , int return_value_used ) 
{ zval *object1 ;
  zval *object2 ;
  php_date_obj *dateobj1 ;
  php_date_obj *dateobj2 ;
  php_interval_obj *interval ;
  long absolute ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z___0 ;
  zval *__z___1 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3749] == 0) {
    {
    fprintf(_coverage_fout, "3749\n");
    fflush(_coverage_fout);
    ___coverage_array[3749] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  absolute = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3750] == 0) {
    {
    fprintf(_coverage_fout, "3750\n");
    fflush(_coverage_fout);
    ___coverage_array[3750] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "OO|l", & object1,
                                     date_ce_date, & object2, date_ce_date,
                                     & absolute);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3751] == 0) {
    {
    fprintf(_coverage_fout, "3751\n");
    fflush(_coverage_fout);
    ___coverage_array[3751] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3730] == 0) {
      {
      fprintf(_coverage_fout, "3730\n");
      fflush(_coverage_fout);
      ___coverage_array[3730] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3727] == 0) {
        {
        fprintf(_coverage_fout, "3727\n");
        fflush(_coverage_fout);
        ___coverage_array[3727] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3728] == 0) {
        {
        fprintf(_coverage_fout, "3728\n");
        fflush(_coverage_fout);
        ___coverage_array[3728] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3729] == 0) {
        {
        fprintf(_coverage_fout, "3729\n");
        fflush(_coverage_fout);
        ___coverage_array[3729] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3731] == 0) {
      {
      fprintf(_coverage_fout, "3731\n");
      fflush(_coverage_fout);
      ___coverage_array[3731] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3732] == 0) {
      {
      fprintf(_coverage_fout, "3732\n");
      fflush(_coverage_fout);
      ___coverage_array[3732] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3752] == 0) {
    {
    fprintf(_coverage_fout, "3752\n");
    fflush(_coverage_fout);
    ___coverage_array[3752] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3753] == 0) {
    {
    fprintf(_coverage_fout, "3753\n");
    fflush(_coverage_fout);
    ___coverage_array[3753] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj1 = (php_date_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3754] == 0) {
    {
    fprintf(_coverage_fout, "3754\n");
    fflush(_coverage_fout);
    ___coverage_array[3754] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)object2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3755] == 0) {
    {
    fprintf(_coverage_fout, "3755\n");
    fflush(_coverage_fout);
    ___coverage_array[3755] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj2 = (php_date_obj *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3756] == 0) {
    {
    fprintf(_coverage_fout, "3756\n");
    fflush(_coverage_fout);
    ___coverage_array[3756] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj1->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3736] == 0) {
      {
      fprintf(_coverage_fout, "3736\n");
      fflush(_coverage_fout);
      ___coverage_array[3736] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3737] == 0) {
      {
      fprintf(_coverage_fout, "3737\n");
      fflush(_coverage_fout);
      ___coverage_array[3737] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3733] == 0) {
        {
        fprintf(_coverage_fout, "3733\n");
        fflush(_coverage_fout);
        ___coverage_array[3733] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3734] == 0) {
        {
        fprintf(_coverage_fout, "3734\n");
        fflush(_coverage_fout);
        ___coverage_array[3734] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3735] == 0) {
        {
        fprintf(_coverage_fout, "3735\n");
        fflush(_coverage_fout);
        ___coverage_array[3735] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3738] == 0) {
      {
      fprintf(_coverage_fout, "3738\n");
      fflush(_coverage_fout);
      ___coverage_array[3738] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3739] == 0) {
      {
      fprintf(_coverage_fout, "3739\n");
      fflush(_coverage_fout);
      ___coverage_array[3739] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3757] == 0) {
    {
    fprintf(_coverage_fout, "3757\n");
    fflush(_coverage_fout);
    ___coverage_array[3757] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! dateobj2->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3743] == 0) {
      {
      fprintf(_coverage_fout, "3743\n");
      fflush(_coverage_fout);
      ___coverage_array[3743] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3744] == 0) {
      {
      fprintf(_coverage_fout, "3744\n");
      fflush(_coverage_fout);
      ___coverage_array[3744] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3740] == 0) {
        {
        fprintf(_coverage_fout, "3740\n");
        fflush(_coverage_fout);
        ___coverage_array[3740] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3741] == 0) {
        {
        fprintf(_coverage_fout, "3741\n");
        fflush(_coverage_fout);
        ___coverage_array[3741] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3742] == 0) {
        {
        fprintf(_coverage_fout, "3742\n");
        fflush(_coverage_fout);
        ___coverage_array[3742] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3745] == 0) {
      {
      fprintf(_coverage_fout, "3745\n");
      fflush(_coverage_fout);
      ___coverage_array[3745] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3746] == 0) {
      {
      fprintf(_coverage_fout, "3746\n");
      fflush(_coverage_fout);
      ___coverage_array[3746] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3758] == 0) {
    {
    fprintf(_coverage_fout, "3758\n");
    fflush(_coverage_fout);
    ___coverage_array[3758] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj1->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3759] == 0) {
    {
    fprintf(_coverage_fout, "3759\n");
    fflush(_coverage_fout);
    ___coverage_array[3759] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_update_ts(dateobj2->time, (timelib_tzinfo *)((void *)0));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3760] == 0) {
    {
    fprintf(_coverage_fout, "3760\n");
    fflush(_coverage_fout);
    ___coverage_array[3760] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_instantiate(date_ce_interval, return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3761] == 0) {
    {
    fprintf(_coverage_fout, "3761\n");
    fflush(_coverage_fout);
    ___coverage_array[3761] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zend_object_store_get_object((zval const   *)return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3762] == 0) {
    {
    fprintf(_coverage_fout, "3762\n");
    fflush(_coverage_fout);
    ___coverage_array[3762] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  interval = (php_interval_obj *)tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3763] == 0) {
    {
    fprintf(_coverage_fout, "3763\n");
    fflush(_coverage_fout);
    ___coverage_array[3763] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  interval->diff = timelib_diff(dateobj1->time, dateobj2->time);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3764] == 0) {
    {
    fprintf(_coverage_fout, "3764\n");
    fflush(_coverage_fout);
    ___coverage_array[3764] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (absolute) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3747] == 0) {
      {
      fprintf(_coverage_fout, "3747\n");
      fflush(_coverage_fout);
      ___coverage_array[3747] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (interval->diff)->invert = 0;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3748] == 0) {
      {
      fprintf(_coverage_fout, "3748\n");
      fflush(_coverage_fout);
      ___coverage_array[3748] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3765] == 0) {
    {
    fprintf(_coverage_fout, "3765\n");
    fflush(_coverage_fout);
    ___coverage_array[3765] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  interval->initialized = 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3766] == 0) {
    {
    fprintf(_coverage_fout, "3766\n");
    fflush(_coverage_fout);
    ___coverage_array[3766] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int timezone_initialize(timelib_tzinfo **tzi , char *tz ) 
{ char *tzid ;
  timelib_tzdb const   *tmp ;
  timelib_tzdb const   *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;
  timelib_tzdb const   *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3780] == 0) {
    {
    fprintf(_coverage_fout, "3780\n");
    fflush(_coverage_fout);
    ___coverage_array[3780] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *tzi = (timelib_tzinfo *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3781] == 0) {
    {
    fprintf(_coverage_fout, "3781\n");
    fflush(_coverage_fout);
    ___coverage_array[3781] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzid = timelib_timezone_id_from_abbr((char const   *)tz, -1L, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3782] == 0) {
    {
    fprintf(_coverage_fout, "3782\n");
    fflush(_coverage_fout);
    ___coverage_array[3782] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tzid) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3770] == 0) {
      {
      fprintf(_coverage_fout, "3770\n");
      fflush(_coverage_fout);
      ___coverage_array[3770] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (php_date_global_timezone_db) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3767] == 0) {
        {
        fprintf(_coverage_fout, "3767\n");
        fflush(_coverage_fout);
        ___coverage_array[3767] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = (timelib_tzdb const   *)php_date_global_timezone_db;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3768] == 0) {
        {
        fprintf(_coverage_fout, "3768\n");
        fflush(_coverage_fout);
        ___coverage_array[3768] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = timelib_builtin_db();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3769] == 0) {
        {
        fprintf(_coverage_fout, "3769\n");
        fflush(_coverage_fout);
        ___coverage_array[3769] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = tmp;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3771] == 0) {
      {
      fprintf(_coverage_fout, "3771\n");
      fflush(_coverage_fout);
      ___coverage_array[3771] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tzi = php_date_parse_tzfile(tzid, tmp___0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3775] == 0) {
      {
      fprintf(_coverage_fout, "3775\n");
      fflush(_coverage_fout);
      ___coverage_array[3775] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (php_date_global_timezone_db) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3772] == 0) {
        {
        fprintf(_coverage_fout, "3772\n");
        fflush(_coverage_fout);
        ___coverage_array[3772] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = (timelib_tzdb const   *)php_date_global_timezone_db;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3773] == 0) {
        {
        fprintf(_coverage_fout, "3773\n");
        fflush(_coverage_fout);
        ___coverage_array[3773] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = timelib_builtin_db();
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3774] == 0) {
        {
        fprintf(_coverage_fout, "3774\n");
        fflush(_coverage_fout);
        ___coverage_array[3774] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = tmp___1;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3776] == 0) {
      {
      fprintf(_coverage_fout, "3776\n");
      fflush(_coverage_fout);
      ___coverage_array[3776] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *tzi = php_date_parse_tzfile(tz, tmp___2);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3783] == 0) {
    {
    fprintf(_coverage_fout, "3783\n");
    fflush(_coverage_fout);
    ___coverage_array[3783] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (*tzi) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3777] == 0) {
      {
      fprintf(_coverage_fout, "3777\n");
      fflush(_coverage_fout);
      ___coverage_array[3777] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3778] == 0) {
      {
      fprintf(_coverage_fout, "3778\n");
      fflush(_coverage_fout);
      ___coverage_array[3778] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Unknown or bad timezone (%s)", tz);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3779] == 0) {
      {
      fprintf(_coverage_fout, "3779\n");
      fflush(_coverage_fout);
      ___coverage_array[3779] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (-1);
  }
}
}
void zif_timezone_open(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) 
{ char *tz ;
  int tz_len ;
  timelib_tzinfo *tzi ;
  php_timezone_obj *tzobj ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  int tmp___0 ;
  zval __attribute__((__visibility__("default")))  *tmp___1 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3796] == 0) {
    {
    fprintf(_coverage_fout, "3796\n");
    fflush(_coverage_fout);
    ___coverage_array[3796] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3797] == 0) {
    {
    fprintf(_coverage_fout, "3797\n");
    fflush(_coverage_fout);
    ___coverage_array[3797] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s", & tz, & tz_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3787] == 0) {
      {
      fprintf(_coverage_fout, "3787\n");
      fflush(_coverage_fout);
      ___coverage_array[3787] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3784] == 0) {
        {
        fprintf(_coverage_fout, "3784\n");
        fflush(_coverage_fout);
        ___coverage_array[3784] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3785] == 0) {
        {
        fprintf(_coverage_fout, "3785\n");
        fflush(_coverage_fout);
        ___coverage_array[3785] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3786] == 0) {
        {
        fprintf(_coverage_fout, "3786\n");
        fflush(_coverage_fout);
        ___coverage_array[3786] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3788] == 0) {
      {
      fprintf(_coverage_fout, "3788\n");
      fflush(_coverage_fout);
      ___coverage_array[3788] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3789] == 0) {
      {
      fprintf(_coverage_fout, "3789\n");
      fflush(_coverage_fout);
      ___coverage_array[3789] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3799] == 0) {
    {
    fprintf(_coverage_fout, "3799\n");
    fflush(_coverage_fout);
    ___coverage_array[3799] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = timezone_initialize(& tzi, tz);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3800] == 0) {
    {
    fprintf(_coverage_fout, "3800\n");
    fflush(_coverage_fout);
    ___coverage_array[3800] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (0 != tmp___0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3793] == 0) {
      {
      fprintf(_coverage_fout, "3793\n");
      fflush(_coverage_fout);
      ___coverage_array[3793] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3790] == 0) {
        {
        fprintf(_coverage_fout, "3790\n");
        fflush(_coverage_fout);
        ___coverage_array[3790] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3791] == 0) {
        {
        fprintf(_coverage_fout, "3791\n");
        fflush(_coverage_fout);
        ___coverage_array[3791] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3792] == 0) {
        {
        fprintf(_coverage_fout, "3792\n");
        fflush(_coverage_fout);
        ___coverage_array[3792] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3795] == 0) {
      {
      fprintf(_coverage_fout, "3795\n");
      fflush(_coverage_fout);
      ___coverage_array[3795] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3801] == 0) {
    {
    fprintf(_coverage_fout, "3801\n");
    fflush(_coverage_fout);
    ___coverage_array[3801] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = php_date_instantiate(date_ce_timezone, return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3802] == 0) {
    {
    fprintf(_coverage_fout, "3802\n");
    fflush(_coverage_fout);
    ___coverage_array[3802] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = zend_object_store_get_object((zval const   *)tmp___1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3803] == 0) {
    {
    fprintf(_coverage_fout, "3803\n");
    fflush(_coverage_fout);
    ___coverage_array[3803] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj = (php_timezone_obj *)tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3804] == 0) {
    {
    fprintf(_coverage_fout, "3804\n");
    fflush(_coverage_fout);
    ___coverage_array[3804] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj->type = 3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3805] == 0) {
    {
    fprintf(_coverage_fout, "3805\n");
    fflush(_coverage_fout);
    ___coverage_array[3805] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj->tzi.tz = tzi;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3806] == 0) {
    {
    fprintf(_coverage_fout, "3806\n");
    fflush(_coverage_fout);
    ___coverage_array[3806] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj->initialized = 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3807] == 0) {
    {
    fprintf(_coverage_fout, "3807\n");
    fflush(_coverage_fout);
    ___coverage_array[3807] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zim_DateTimeZone___construct(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) 
{ char *tz ;
  int tz_len ;
  timelib_tzinfo *tzi ;
  php_timezone_obj *tzobj ;
  zend_error_handling error_handling ;
  void __attribute__((__visibility__("default")))  *tmp ;
  int tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3817] == 0) {
    {
    fprintf(_coverage_fout, "3817\n");
    fflush(_coverage_fout);
    ___coverage_array[3817] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3818] == 0) {
    {
    fprintf(_coverage_fout, "3818\n");
    fflush(_coverage_fout);
    ___coverage_array[3818] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_replace_error_handling((enum __anonenum_zend_error_handling_t_47 )2,
                              (zend_class_entry *)((void *)0), & error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3819] == 0) {
    {
    fprintf(_coverage_fout, "3819\n");
    fflush(_coverage_fout);
    ___coverage_array[3819] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_parse_parameters(ht, "s", & tz, & tz_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3820] == 0) {
    {
    fprintf(_coverage_fout, "3820\n");
    fflush(_coverage_fout);
    ___coverage_array[3820] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (0 == (int )tmp___1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3814] == 0) {
      {
      fprintf(_coverage_fout, "3814\n");
      fflush(_coverage_fout);
      ___coverage_array[3814] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = timezone_initialize(& tzi, tz);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (0 == tmp___0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3808] == 0) {
        {
        fprintf(_coverage_fout, "3808\n");
        fflush(_coverage_fout);
        ___coverage_array[3808] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = zend_object_store_get_object((zval const   *)this_ptr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3809] == 0) {
        {
        fprintf(_coverage_fout, "3809\n");
        fflush(_coverage_fout);
        ___coverage_array[3809] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tzobj = (php_timezone_obj *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3810] == 0) {
        {
        fprintf(_coverage_fout, "3810\n");
        fflush(_coverage_fout);
        ___coverage_array[3810] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tzobj->type = 3;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3811] == 0) {
        {
        fprintf(_coverage_fout, "3811\n");
        fflush(_coverage_fout);
        ___coverage_array[3811] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tzobj->tzi.tz = tzi;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3812] == 0) {
        {
        fprintf(_coverage_fout, "3812\n");
        fflush(_coverage_fout);
        ___coverage_array[3812] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tzobj->initialized = 1;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3813] == 0) {
        {
        fprintf(_coverage_fout, "3813\n");
        fflush(_coverage_fout);
        ___coverage_array[3813] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      this_ptr->type = (unsigned char)0;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3816] == 0) {
      {
      fprintf(_coverage_fout, "3816\n");
      fflush(_coverage_fout);
      ___coverage_array[3816] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3821] == 0) {
    {
    fprintf(_coverage_fout, "3821\n");
    fflush(_coverage_fout);
    ___coverage_array[3821] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_restore_error_handling(& error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3822] == 0) {
    {
    fprintf(_coverage_fout, "3822\n");
    fflush(_coverage_fout);
    ___coverage_array[3822] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_timezone_name_get(int ht , zval *return_value ,
                           zval **return_value_ptr , zval *this_ptr ,
                           int return_value_used ) 
{ zval *object ;
  php_timezone_obj *tzobj ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  char const   *__s ;
  zval *__z___1 ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;
  char *tmpstr ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  timelib_sll utc_offset ;
  int tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;
  char const   *__s___0 ;
  zval *__z___2 ;
  size_t tmp___7 ;
  char __attribute__((__visibility__("default")))  *tmp___8 ;
  char const   *__s___1 ;
  zval *__z___3 ;
  size_t tmp___9 ;
  char __attribute__((__visibility__("default")))  *tmp___10 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3871] == 0) {
    {
    fprintf(_coverage_fout, "3871\n");
    fflush(_coverage_fout);
    ___coverage_array[3871] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & object,
                                     date_ce_timezone);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3872] == 0) {
    {
    fprintf(_coverage_fout, "3872\n");
    fflush(_coverage_fout);
    ___coverage_array[3872] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3826] == 0) {
      {
      fprintf(_coverage_fout, "3826\n");
      fflush(_coverage_fout);
      ___coverage_array[3826] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3823] == 0) {
        {
        fprintf(_coverage_fout, "3823\n");
        fflush(_coverage_fout);
        ___coverage_array[3823] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3824] == 0) {
        {
        fprintf(_coverage_fout, "3824\n");
        fflush(_coverage_fout);
        ___coverage_array[3824] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3825] == 0) {
        {
        fprintf(_coverage_fout, "3825\n");
        fflush(_coverage_fout);
        ___coverage_array[3825] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3827] == 0) {
      {
      fprintf(_coverage_fout, "3827\n");
      fflush(_coverage_fout);
      ___coverage_array[3827] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3828] == 0) {
      {
      fprintf(_coverage_fout, "3828\n");
      fflush(_coverage_fout);
      ___coverage_array[3828] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3873] == 0) {
    {
    fprintf(_coverage_fout, "3873\n");
    fflush(_coverage_fout);
    ___coverage_array[3873] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3874] == 0) {
    {
    fprintf(_coverage_fout, "3874\n");
    fflush(_coverage_fout);
    ___coverage_array[3874] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj = (php_timezone_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3875] == 0) {
    {
    fprintf(_coverage_fout, "3875\n");
    fflush(_coverage_fout);
    ___coverage_array[3875] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! tzobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3832] == 0) {
      {
      fprintf(_coverage_fout, "3832\n");
      fflush(_coverage_fout);
      ___coverage_array[3832] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTimeZone object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3829] == 0) {
        {
        fprintf(_coverage_fout, "3829\n");
        fflush(_coverage_fout);
        ___coverage_array[3829] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3830] == 0) {
        {
        fprintf(_coverage_fout, "3830\n");
        fflush(_coverage_fout);
        ___coverage_array[3830] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3831] == 0) {
        {
        fprintf(_coverage_fout, "3831\n");
        fflush(_coverage_fout);
        ___coverage_array[3831] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3835] == 0) {
      {
      fprintf(_coverage_fout, "3835\n");
      fflush(_coverage_fout);
      ___coverage_array[3835] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  switch (tzobj->type) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3858] == 0) {
    {
    fprintf(_coverage_fout, "3858\n");
    fflush(_coverage_fout);
    ___coverage_array[3858] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3836] == 0) {
      {
      fprintf(_coverage_fout, "3836\n");
      fflush(_coverage_fout);
      ___coverage_array[3836] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)(tzobj->tzi.tz)->name;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3837] == 0) {
      {
      fprintf(_coverage_fout, "3837\n");
      fflush(_coverage_fout);
      ___coverage_array[3837] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3838] == 0) {
      {
      fprintf(_coverage_fout, "3838\n");
      fflush(_coverage_fout);
      ___coverage_array[3838] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3839] == 0) {
      {
      fprintf(_coverage_fout, "3839\n");
      fflush(_coverage_fout);
      ___coverage_array[3839] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.str.len = (int )tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3840] == 0) {
      {
      fprintf(_coverage_fout, "3840\n");
      fflush(_coverage_fout);
      ___coverage_array[3840] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = _estrndup(__s, (unsigned int )__z___1->value.str.len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3841] == 0) {
      {
      fprintf(_coverage_fout, "3841\n");
      fflush(_coverage_fout);
      ___coverage_array[3841] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.str.val = (char *)tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3842] == 0) {
      {
      fprintf(_coverage_fout, "3842\n");
      fflush(_coverage_fout);
      ___coverage_array[3842] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3859] == 0) {
    {
    fprintf(_coverage_fout, "3859\n");
    fflush(_coverage_fout);
    ___coverage_array[3859] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3860] == 0) {
    {
    fprintf(_coverage_fout, "3860\n");
    fflush(_coverage_fout);
    ___coverage_array[3860] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___3 = _emalloc(sizeof("UTC+05:00"));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3861] == 0) {
    {
    fprintf(_coverage_fout, "3861\n");
    fflush(_coverage_fout);
    ___coverage_array[3861] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmpstr = (char *)tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3862] == 0) {
    {
    fprintf(_coverage_fout, "3862\n");
    fflush(_coverage_fout);
    ___coverage_array[3862] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  utc_offset = tzobj->tzi.utc_offset;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3863] == 0) {
    {
    fprintf(_coverage_fout, "3863\n");
    fflush(_coverage_fout);
    ___coverage_array[3863] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = abs((int )(utc_offset % 60LL));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3864] == 0) {
    {
    fprintf(_coverage_fout, "3864\n");
    fflush(_coverage_fout);
    ___coverage_array[3864] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___5 = abs((int )(utc_offset / 60LL));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3865] == 0) {
    {
    fprintf(_coverage_fout, "3865\n");
    fflush(_coverage_fout);
    ___coverage_array[3865] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (utc_offset > 0LL) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3843] == 0) {
      {
      fprintf(_coverage_fout, "3843\n");
      fflush(_coverage_fout);
      ___coverage_array[3843] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = '-';
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3844] == 0) {
      {
      fprintf(_coverage_fout, "3844\n");
      fflush(_coverage_fout);
      ___coverage_array[3844] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = '+';
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3866] == 0) {
    {
    fprintf(_coverage_fout, "3866\n");
    fflush(_coverage_fout);
    ___coverage_array[3866] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  ap_php_snprintf(tmpstr, sizeof("+05:00"), "%c%02d:%02d", tmp___6, tmp___5,
                  tmp___4);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3867] == 0) {
    {
    fprintf(_coverage_fout, "3867\n");
    fflush(_coverage_fout);
    ___coverage_array[3867] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3845] == 0) {
      {
      fprintf(_coverage_fout, "3845\n");
      fflush(_coverage_fout);
      ___coverage_array[3845] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s___0 = (char const   *)tmpstr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3846] == 0) {
      {
      fprintf(_coverage_fout, "3846\n");
      fflush(_coverage_fout);
      ___coverage_array[3846] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3847] == 0) {
      {
      fprintf(_coverage_fout, "3847\n");
      fflush(_coverage_fout);
      ___coverage_array[3847] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = strlen(__s___0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3848] == 0) {
      {
      fprintf(_coverage_fout, "3848\n");
      fflush(_coverage_fout);
      ___coverage_array[3848] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->value.str.len = (int )tmp___7;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3849] == 0) {
      {
      fprintf(_coverage_fout, "3849\n");
      fflush(_coverage_fout);
      ___coverage_array[3849] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s___0));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3850] == 0) {
      {
      fprintf(_coverage_fout, "3850\n");
      fflush(_coverage_fout);
      ___coverage_array[3850] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___2->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3868] == 0) {
    {
    fprintf(_coverage_fout, "3868\n");
    fflush(_coverage_fout);
    ___coverage_array[3868] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3869] == 0) {
    {
    fprintf(_coverage_fout, "3869\n");
    fflush(_coverage_fout);
    ___coverage_array[3869] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3851] == 0) {
      {
      fprintf(_coverage_fout, "3851\n");
      fflush(_coverage_fout);
      ___coverage_array[3851] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s___1 = (char const   *)tzobj->tzi.z.abbr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3852] == 0) {
      {
      fprintf(_coverage_fout, "3852\n");
      fflush(_coverage_fout);
      ___coverage_array[3852] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3853] == 0) {
      {
      fprintf(_coverage_fout, "3853\n");
      fflush(_coverage_fout);
      ___coverage_array[3853] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = strlen(__s___1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3854] == 0) {
      {
      fprintf(_coverage_fout, "3854\n");
      fflush(_coverage_fout);
      ___coverage_array[3854] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3->value.str.len = (int )tmp___9;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3855] == 0) {
      {
      fprintf(_coverage_fout, "3855\n");
      fflush(_coverage_fout);
      ___coverage_array[3855] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = _estrndup(__s___1, (unsigned int )__z___3->value.str.len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3856] == 0) {
      {
      fprintf(_coverage_fout, "3856\n");
      fflush(_coverage_fout);
      ___coverage_array[3856] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3->value.str.val = (char *)tmp___10;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3857] == 0) {
      {
      fprintf(_coverage_fout, "3857\n");
      fflush(_coverage_fout);
      ___coverage_array[3857] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3870] == 0) {
    {
    fprintf(_coverage_fout, "3870\n");
    fflush(_coverage_fout);
    ___coverage_array[3870] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3876] == 0) {
    {
    fprintf(_coverage_fout, "3876\n");
    fflush(_coverage_fout);
    ___coverage_array[3876] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_timezone_name_from_abbr(int ht , zval *return_value ,
                                 zval **return_value_ptr , zval *this_ptr ,
                                 int return_value_used ) 
{ char *abbr ;
  char *tzid ;
  int abbr_len ;
  long gmtoffset ;
  long isdst ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3897] == 0) {
    {
    fprintf(_coverage_fout, "3897\n");
    fflush(_coverage_fout);
    ___coverage_array[3897] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  gmtoffset = -1L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3898] == 0) {
    {
    fprintf(_coverage_fout, "3898\n");
    fflush(_coverage_fout);
    ___coverage_array[3898] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  isdst = -1L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3899] == 0) {
    {
    fprintf(_coverage_fout, "3899\n");
    fflush(_coverage_fout);
    ___coverage_array[3899] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s|ll", & abbr, & abbr_len, & gmtoffset,
                              & isdst);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3900] == 0) {
    {
    fprintf(_coverage_fout, "3900\n");
    fflush(_coverage_fout);
    ___coverage_array[3900] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3880] == 0) {
      {
      fprintf(_coverage_fout, "3880\n");
      fflush(_coverage_fout);
      ___coverage_array[3880] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3877] == 0) {
        {
        fprintf(_coverage_fout, "3877\n");
        fflush(_coverage_fout);
        ___coverage_array[3877] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3878] == 0) {
        {
        fprintf(_coverage_fout, "3878\n");
        fflush(_coverage_fout);
        ___coverage_array[3878] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3879] == 0) {
        {
        fprintf(_coverage_fout, "3879\n");
        fflush(_coverage_fout);
        ___coverage_array[3879] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3881] == 0) {
      {
      fprintf(_coverage_fout, "3881\n");
      fflush(_coverage_fout);
      ___coverage_array[3881] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3901] == 0) {
    {
    fprintf(_coverage_fout, "3901\n");
    fflush(_coverage_fout);
    ___coverage_array[3901] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzid = timelib_timezone_id_from_abbr((char const   *)abbr, gmtoffset,
                                       (int )isdst);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3902] == 0) {
    {
    fprintf(_coverage_fout, "3902\n");
    fflush(_coverage_fout);
    ___coverage_array[3902] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tzid) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3890] == 0) {
      {
      fprintf(_coverage_fout, "3890\n");
      fflush(_coverage_fout);
      ___coverage_array[3890] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3883] == 0) {
        {
        fprintf(_coverage_fout, "3883\n");
        fflush(_coverage_fout);
        ___coverage_array[3883] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s = (char const   *)tzid;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3884] == 0) {
        {
        fprintf(_coverage_fout, "3884\n");
        fflush(_coverage_fout);
        ___coverage_array[3884] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3885] == 0) {
        {
        fprintf(_coverage_fout, "3885\n");
        fflush(_coverage_fout);
        ___coverage_array[3885] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___0 = strlen(__s);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3886] == 0) {
        {
        fprintf(_coverage_fout, "3886\n");
        fflush(_coverage_fout);
        ___coverage_array[3886] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.str.len = (int )tmp___0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3887] == 0) {
        {
        fprintf(_coverage_fout, "3887\n");
        fflush(_coverage_fout);
        ___coverage_array[3887] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = _estrndup(__s, (unsigned int )__z___0->value.str.len);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3888] == 0) {
        {
        fprintf(_coverage_fout, "3888\n");
        fflush(_coverage_fout);
        ___coverage_array[3888] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.str.val = (char *)tmp___1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3889] == 0) {
        {
        fprintf(_coverage_fout, "3889\n");
        fflush(_coverage_fout);
        ___coverage_array[3889] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)6;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3891] == 0) {
      {
      fprintf(_coverage_fout, "3891\n");
      fflush(_coverage_fout);
      ___coverage_array[3891] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3895] == 0) {
      {
      fprintf(_coverage_fout, "3895\n");
      fflush(_coverage_fout);
      ___coverage_array[3895] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3892] == 0) {
        {
        fprintf(_coverage_fout, "3892\n");
        fflush(_coverage_fout);
        ___coverage_array[3892] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3893] == 0) {
        {
        fprintf(_coverage_fout, "3893\n");
        fflush(_coverage_fout);
        ___coverage_array[3893] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3894] == 0) {
        {
        fprintf(_coverage_fout, "3894\n");
        fflush(_coverage_fout);
        ___coverage_array[3894] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3896] == 0) {
      {
      fprintf(_coverage_fout, "3896\n");
      fflush(_coverage_fout);
      ___coverage_array[3896] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
}
}
void zif_timezone_offset_get(int ht , zval *return_value ,
                             zval **return_value_ptr , zval *this_ptr ,
                             int return_value_used ) 
{ zval *object ;
  zval *dateobject ;
  php_timezone_obj *tzobj ;
  php_date_obj *dateobj ;
  timelib_time_offset *offset ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z___1 ;
  zval *__z___2 ;
  zval *__z___3 ;
  zval *__z___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3936] == 0) {
    {
    fprintf(_coverage_fout, "3936\n");
    fflush(_coverage_fout);
    ___coverage_array[3936] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "OO", & object,
                                     date_ce_timezone, & dateobject,
                                     date_ce_date);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3937] == 0) {
    {
    fprintf(_coverage_fout, "3937\n");
    fflush(_coverage_fout);
    ___coverage_array[3937] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3906] == 0) {
      {
      fprintf(_coverage_fout, "3906\n");
      fflush(_coverage_fout);
      ___coverage_array[3906] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3903] == 0) {
        {
        fprintf(_coverage_fout, "3903\n");
        fflush(_coverage_fout);
        ___coverage_array[3903] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3904] == 0) {
        {
        fprintf(_coverage_fout, "3904\n");
        fflush(_coverage_fout);
        ___coverage_array[3904] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3905] == 0) {
        {
        fprintf(_coverage_fout, "3905\n");
        fflush(_coverage_fout);
        ___coverage_array[3905] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3907] == 0) {
      {
      fprintf(_coverage_fout, "3907\n");
      fflush(_coverage_fout);
      ___coverage_array[3907] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3908] == 0) {
      {
      fprintf(_coverage_fout, "3908\n");
      fflush(_coverage_fout);
      ___coverage_array[3908] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3938] == 0) {
    {
    fprintf(_coverage_fout, "3938\n");
    fflush(_coverage_fout);
    ___coverage_array[3938] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3939] == 0) {
    {
    fprintf(_coverage_fout, "3939\n");
    fflush(_coverage_fout);
    ___coverage_array[3939] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj = (php_timezone_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3940] == 0) {
    {
    fprintf(_coverage_fout, "3940\n");
    fflush(_coverage_fout);
    ___coverage_array[3940] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! tzobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3912] == 0) {
      {
      fprintf(_coverage_fout, "3912\n");
      fflush(_coverage_fout);
      ___coverage_array[3912] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTimeZone object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3913] == 0) {
      {
      fprintf(_coverage_fout, "3913\n");
      fflush(_coverage_fout);
      ___coverage_array[3913] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3909] == 0) {
        {
        fprintf(_coverage_fout, "3909\n");
        fflush(_coverage_fout);
        ___coverage_array[3909] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3910] == 0) {
        {
        fprintf(_coverage_fout, "3910\n");
        fflush(_coverage_fout);
        ___coverage_array[3910] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3911] == 0) {
        {
        fprintf(_coverage_fout, "3911\n");
        fflush(_coverage_fout);
        ___coverage_array[3911] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3914] == 0) {
      {
      fprintf(_coverage_fout, "3914\n");
      fflush(_coverage_fout);
      ___coverage_array[3914] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3915] == 0) {
      {
      fprintf(_coverage_fout, "3915\n");
      fflush(_coverage_fout);
      ___coverage_array[3915] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3941] == 0) {
    {
    fprintf(_coverage_fout, "3941\n");
    fflush(_coverage_fout);
    ___coverage_array[3941] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_object_store_get_object((zval const   *)dateobject);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3942] == 0) {
    {
    fprintf(_coverage_fout, "3942\n");
    fflush(_coverage_fout);
    ___coverage_array[3942] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dateobj = (php_date_obj *)tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (! dateobj->time) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3919] == 0) {
      {
      fprintf(_coverage_fout, "3919\n");
      fflush(_coverage_fout);
      ___coverage_array[3919] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTime object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3920] == 0) {
      {
      fprintf(_coverage_fout, "3920\n");
      fflush(_coverage_fout);
      ___coverage_array[3920] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3916] == 0) {
        {
        fprintf(_coverage_fout, "3916\n");
        fflush(_coverage_fout);
        ___coverage_array[3916] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3917] == 0) {
        {
        fprintf(_coverage_fout, "3917\n");
        fflush(_coverage_fout);
        ___coverage_array[3917] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3918] == 0) {
        {
        fprintf(_coverage_fout, "3918\n");
        fflush(_coverage_fout);
        ___coverage_array[3918] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3921] == 0) {
      {
      fprintf(_coverage_fout, "3921\n");
      fflush(_coverage_fout);
      ___coverage_array[3921] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3922] == 0) {
      {
      fprintf(_coverage_fout, "3922\n");
      fflush(_coverage_fout);
      ___coverage_array[3922] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  switch (tzobj->type) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3923] == 0) {
    {
    fprintf(_coverage_fout, "3923\n");
    fflush(_coverage_fout);
    ___coverage_array[3923] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  offset = timelib_get_time_zone_info((dateobj->time)->sse, tzobj->tzi.tz);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3924] == 0) {
    {
    fprintf(_coverage_fout, "3924\n");
    fflush(_coverage_fout);
    ___coverage_array[3924] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2 = return_value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3925] == 0) {
    {
    fprintf(_coverage_fout, "3925\n");
    fflush(_coverage_fout);
    ___coverage_array[3925] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->value.lval = (long )offset->offset;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3926] == 0) {
    {
    fprintf(_coverage_fout, "3926\n");
    fflush(_coverage_fout);
    ___coverage_array[3926] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___2->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3927] == 0) {
    {
    fprintf(_coverage_fout, "3927\n");
    fflush(_coverage_fout);
    ___coverage_array[3927] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_offset_dtor(offset);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3928] == 0) {
    {
    fprintf(_coverage_fout, "3928\n");
    fflush(_coverage_fout);
    ___coverage_array[3928] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  __z___3 = return_value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3929] == 0) {
    {
    fprintf(_coverage_fout, "3929\n");
    fflush(_coverage_fout);
    ___coverage_array[3929] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___3->value.lval = (long )(tzobj->tzi.utc_offset * -60LL);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3930] == 0) {
    {
    fprintf(_coverage_fout, "3930\n");
    fflush(_coverage_fout);
    ___coverage_array[3930] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___3->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3931] == 0) {
    {
    fprintf(_coverage_fout, "3931\n");
    fflush(_coverage_fout);
    ___coverage_array[3931] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3932] == 0) {
    {
    fprintf(_coverage_fout, "3932\n");
    fflush(_coverage_fout);
    ___coverage_array[3932] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  __z___4 = return_value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3933] == 0) {
    {
    fprintf(_coverage_fout, "3933\n");
    fflush(_coverage_fout);
    ___coverage_array[3933] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___4->value.lval = (long )((tzobj->tzi.z.utc_offset - (timelib_sll )(tzobj->tzi.z.dst * 60)) * -60LL);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3934] == 0) {
    {
    fprintf(_coverage_fout, "3934\n");
    fflush(_coverage_fout);
    ___coverage_array[3934] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___4->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[3935] == 0) {
    {
    fprintf(_coverage_fout, "3935\n");
    fflush(_coverage_fout);
    ___coverage_array[3935] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
}
}
void zif_timezone_transitions_get(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) 
{ zval *object ;
  zval *element ;
  php_timezone_obj *tzobj ;
  unsigned int i ;
  unsigned int begin ;
  unsigned int found ;
  long timestamp_begin ;
  long timestamp_end ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  size_t tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;
  size_t tmp___4 ;
  size_t tmp___5 ;
  size_t tmp___6 ;
  size_t tmp___7 ;
  void __attribute__((__visibility__("default")))  *tmp___8 ;
  size_t tmp___9 ;
  char __attribute__((__visibility__("default")))  *tmp___10 ;
  size_t tmp___11 ;
  size_t tmp___12 ;
  size_t tmp___13 ;
  size_t tmp___14 ;
  void __attribute__((__visibility__("default")))  *tmp___15 ;
  size_t tmp___16 ;
  char __attribute__((__visibility__("default")))  *tmp___17 ;
  size_t tmp___18 ;
  size_t tmp___19 ;
  size_t tmp___20 ;
  size_t tmp___21 ;
  void __attribute__((__visibility__("default")))  *tmp___22 ;
  size_t tmp___23 ;
  char __attribute__((__visibility__("default")))  *tmp___24 ;
  size_t tmp___25 ;
  size_t tmp___26 ;
  size_t tmp___27 ;
  size_t tmp___28 ;
  void __attribute__((__visibility__("default")))  *tmp___29 ;
  size_t tmp___30 ;
  char __attribute__((__visibility__("default")))  *tmp___31 ;
  size_t tmp___32 ;
  size_t tmp___33 ;
  size_t tmp___34 ;
  size_t tmp___35 ;
  void __attribute__((__visibility__("default")))  *tmp___36 ;
  size_t tmp___37 ;
  char __attribute__((__visibility__("default")))  *tmp___38 ;
  size_t tmp___39 ;
  size_t tmp___40 ;
  size_t tmp___41 ;
  size_t tmp___42 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4100] == 0) {
    {
    fprintf(_coverage_fout, "4100\n");
    fflush(_coverage_fout);
    ___coverage_array[4100] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  begin = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4101] == 0) {
    {
    fprintf(_coverage_fout, "4101\n");
    fflush(_coverage_fout);
    ___coverage_array[4101] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp_begin = (-0x7FFFFFFF-1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4102] == 0) {
    {
    fprintf(_coverage_fout, "4102\n");
    fflush(_coverage_fout);
    ___coverage_array[4102] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timestamp_end = 2147483647L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4103] == 0) {
    {
    fprintf(_coverage_fout, "4103\n");
    fflush(_coverage_fout);
    ___coverage_array[4103] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O|ll", & object,
                                     date_ce_timezone, & timestamp_begin,
                                     & timestamp_end);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4104] == 0) {
    {
    fprintf(_coverage_fout, "4104\n");
    fflush(_coverage_fout);
    ___coverage_array[4104] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3948] == 0) {
      {
      fprintf(_coverage_fout, "3948\n");
      fflush(_coverage_fout);
      ___coverage_array[3948] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3945] == 0) {
        {
        fprintf(_coverage_fout, "3945\n");
        fflush(_coverage_fout);
        ___coverage_array[3945] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3946] == 0) {
        {
        fprintf(_coverage_fout, "3946\n");
        fflush(_coverage_fout);
        ___coverage_array[3946] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3947] == 0) {
        {
        fprintf(_coverage_fout, "3947\n");
        fflush(_coverage_fout);
        ___coverage_array[3947] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3949] == 0) {
      {
      fprintf(_coverage_fout, "3949\n");
      fflush(_coverage_fout);
      ___coverage_array[3949] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3950] == 0) {
      {
      fprintf(_coverage_fout, "3950\n");
      fflush(_coverage_fout);
      ___coverage_array[3950] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4106] == 0) {
    {
    fprintf(_coverage_fout, "4106\n");
    fflush(_coverage_fout);
    ___coverage_array[4106] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj = (php_timezone_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4107] == 0) {
    {
    fprintf(_coverage_fout, "4107\n");
    fflush(_coverage_fout);
    ___coverage_array[4107] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! tzobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3954] == 0) {
      {
      fprintf(_coverage_fout, "3954\n");
      fflush(_coverage_fout);
      ___coverage_array[3954] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTimeZone object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3955] == 0) {
      {
      fprintf(_coverage_fout, "3955\n");
      fflush(_coverage_fout);
      ___coverage_array[3955] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3951] == 0) {
        {
        fprintf(_coverage_fout, "3951\n");
        fflush(_coverage_fout);
        ___coverage_array[3951] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3952] == 0) {
        {
        fprintf(_coverage_fout, "3952\n");
        fflush(_coverage_fout);
        ___coverage_array[3952] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3953] == 0) {
        {
        fprintf(_coverage_fout, "3953\n");
        fflush(_coverage_fout);
        ___coverage_array[3953] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3956] == 0) {
      {
      fprintf(_coverage_fout, "3956\n");
      fflush(_coverage_fout);
      ___coverage_array[3956] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3957] == 0) {
      {
      fprintf(_coverage_fout, "3957\n");
      fflush(_coverage_fout);
      ___coverage_array[3957] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4108] == 0) {
    {
    fprintf(_coverage_fout, "4108\n");
    fflush(_coverage_fout);
    ___coverage_array[4108] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tzobj->type != 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3961] == 0) {
      {
      fprintf(_coverage_fout, "3961\n");
      fflush(_coverage_fout);
      ___coverage_array[3961] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3958] == 0) {
        {
        fprintf(_coverage_fout, "3958\n");
        fflush(_coverage_fout);
        ___coverage_array[3958] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3959] == 0) {
        {
        fprintf(_coverage_fout, "3959\n");
        fflush(_coverage_fout);
        ___coverage_array[3959] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3960] == 0) {
        {
        fprintf(_coverage_fout, "3960\n");
        fflush(_coverage_fout);
        ___coverage_array[3960] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3962] == 0) {
      {
      fprintf(_coverage_fout, "3962\n");
      fflush(_coverage_fout);
      ___coverage_array[3962] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3963] == 0) {
      {
      fprintf(_coverage_fout, "3963\n");
      fflush(_coverage_fout);
      ___coverage_array[3963] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4109] == 0) {
    {
    fprintf(_coverage_fout, "4109\n");
    fflush(_coverage_fout);
    ___coverage_array[4109] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4110] == 0) {
    {
    fprintf(_coverage_fout, "4110\n");
    fflush(_coverage_fout);
    ___coverage_array[4110] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (timestamp_begin == (-0x7FFFFFFF-1)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3967] == 0) {
      {
      fprintf(_coverage_fout, "3967\n");
      fflush(_coverage_fout);
      ___coverage_array[3967] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3964] == 0) {
        {
        fprintf(_coverage_fout, "3964\n");
        fflush(_coverage_fout);
        ___coverage_array[3964] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___1 = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3965] == 0) {
        {
        fprintf(_coverage_fout, "3965\n");
        fflush(_coverage_fout);
        ___coverage_array[3965] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element = (zval *)tmp___1;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[3966] == 0) {
        {
        fprintf(_coverage_fout, "3966\n");
        fflush(_coverage_fout);
        ___coverage_array[3966] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3968] == 0) {
      {
      fprintf(_coverage_fout, "3968\n");
      fflush(_coverage_fout);
      ___coverage_array[3968] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3969] == 0) {
      {
      fprintf(_coverage_fout, "3969\n");
      fflush(_coverage_fout);
      ___coverage_array[3969] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3970] == 0) {
      {
      fprintf(_coverage_fout, "3970\n");
      fflush(_coverage_fout);
      ___coverage_array[3970] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _array_init(element, 0U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3971] == 0) {
      {
      fprintf(_coverage_fout, "3971\n");
      fflush(_coverage_fout);
      ___coverage_array[3971] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = strlen("ts");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3972] == 0) {
      {
      fprintf(_coverage_fout, "3972\n");
      fflush(_coverage_fout);
      ___coverage_array[3972] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "ts", tmp___2 + 1U, timestamp_begin);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3973] == 0) {
      {
      fprintf(_coverage_fout, "3973\n");
      fflush(_coverage_fout);
      ___coverage_array[3973] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = php_format_date((char *)"Y-m-d\\TH:i:sO", 13, timestamp_begin, 0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___4 = strlen("time");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3975] == 0) {
      {
      fprintf(_coverage_fout, "3975\n");
      fflush(_coverage_fout);
      ___coverage_array[3975] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_string_ex(element, "time", tmp___4 + 1U, (char *)tmp___3, 0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___5 = strlen("offset");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3977] == 0) {
      {
      fprintf(_coverage_fout, "3977\n");
      fflush(_coverage_fout);
      ___coverage_array[3977] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "offset", tmp___5 + 1U,
                      (long )((tzobj->tzi.tz)->type + 0)->offset);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___6 = strlen("isdst");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3979] == 0) {
      {
      fprintf(_coverage_fout, "3979\n");
      fflush(_coverage_fout);
      ___coverage_array[3979] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(element, "isdst", tmp___6 + 1U,
                      ((tzobj->tzi.tz)->type + 0)->isdst);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___7 = strlen("abbr");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3981] == 0) {
      {
      fprintf(_coverage_fout, "3981\n");
      fflush(_coverage_fout);
      ___coverage_array[3981] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_string_ex(element, "abbr", tmp___7 + 1U,
                        (tzobj->tzi.tz)->timezone_abbr + ((tzobj->tzi.tz)->type + 0)->abbr_idx,
                        1);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3982] == 0) {
      {
      fprintf(_coverage_fout, "3982\n");
      fflush(_coverage_fout);
      ___coverage_array[3982] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_zval(return_value, element);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3983] == 0) {
      {
      fprintf(_coverage_fout, "3983\n");
      fflush(_coverage_fout);
      ___coverage_array[3983] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    begin = 0U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[3984] == 0) {
      {
      fprintf(_coverage_fout, "3984\n");
      fflush(_coverage_fout);
      ___coverage_array[3984] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    found = 1U;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4032] == 0) {
      {
      fprintf(_coverage_fout, "4032\n");
      fflush(_coverage_fout);
      ___coverage_array[4032] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    begin = 0U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4033] == 0) {
      {
      fprintf(_coverage_fout, "4033\n");
      fflush(_coverage_fout);
      ___coverage_array[4033] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    found = 0U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4034] == 0) {
      {
      fprintf(_coverage_fout, "4034\n");
      fflush(_coverage_fout);
      ___coverage_array[4034] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((tzobj->tzi.tz)->timecnt > 0U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4030] == 0) {
        {
        fprintf(_coverage_fout, "4030\n");
        fflush(_coverage_fout);
        ___coverage_array[4030] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4027] == 0) {
          {
          fprintf(_coverage_fout, "4027\n");
          fflush(_coverage_fout);
          ___coverage_array[4027] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if ((long )*((tzobj->tzi.tz)->trans + begin) > timestamp_begin) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (begin > 0U) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3988] == 0) {
              {
              fprintf(_coverage_fout, "3988\n");
              fflush(_coverage_fout);
              ___coverage_array[3988] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            while (1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[3985] == 0) {
                {
                fprintf(_coverage_fout, "3985\n");
                fflush(_coverage_fout);
                ___coverage_array[3985] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___8 = _emalloc(sizeof(zval_gc_info ));
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[3986] == 0) {
                {
                fprintf(_coverage_fout, "3986\n");
                fflush(_coverage_fout);
                ___coverage_array[3986] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              element = (zval *)tmp___8;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[3987] == 0) {
                {
                fprintf(_coverage_fout, "3987\n");
                fflush(_coverage_fout);
                ___coverage_array[3987] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3989] == 0) {
              {
              fprintf(_coverage_fout, "3989\n");
              fflush(_coverage_fout);
              ___coverage_array[3989] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            element->refcount__gc = 1U;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3990] == 0) {
              {
              fprintf(_coverage_fout, "3990\n");
              fflush(_coverage_fout);
              ___coverage_array[3990] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            element->is_ref__gc = (unsigned char)0;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3991] == 0) {
              {
              fprintf(_coverage_fout, "3991\n");
              fflush(_coverage_fout);
              ___coverage_array[3991] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _array_init(element, 0U);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3992] == 0) {
              {
              fprintf(_coverage_fout, "3992\n");
              fflush(_coverage_fout);
              ___coverage_array[3992] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___9 = strlen("ts");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3993] == 0) {
              {
              fprintf(_coverage_fout, "3993\n");
              fflush(_coverage_fout);
              ___coverage_array[3993] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_long_ex(element, "ts", tmp___9 + 1U, timestamp_begin);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3994] == 0) {
              {
              fprintf(_coverage_fout, "3994\n");
              fflush(_coverage_fout);
              ___coverage_array[3994] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___10 = php_format_date((char *)"Y-m-d\\TH:i:sO", 13,
                                       timestamp_begin, 0);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3995] == 0) {
              {
              fprintf(_coverage_fout, "3995\n");
              fflush(_coverage_fout);
              ___coverage_array[3995] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___11 = strlen("time");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3996] == 0) {
              {
              fprintf(_coverage_fout, "3996\n");
              fflush(_coverage_fout);
              ___coverage_array[3996] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_string_ex(element, "time", tmp___11 + 1U,
                                (char *)tmp___10, 0);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3997] == 0) {
              {
              fprintf(_coverage_fout, "3997\n");
              fflush(_coverage_fout);
              ___coverage_array[3997] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___12 = strlen("offset");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3998] == 0) {
              {
              fprintf(_coverage_fout, "3998\n");
              fflush(_coverage_fout);
              ___coverage_array[3998] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_long_ex(element, "offset", tmp___12 + 1U,
                              (long )((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + (begin - 1U)))->offset);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[3999] == 0) {
              {
              fprintf(_coverage_fout, "3999\n");
              fflush(_coverage_fout);
              ___coverage_array[3999] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___13 = strlen("isdst");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4000] == 0) {
              {
              fprintf(_coverage_fout, "4000\n");
              fflush(_coverage_fout);
              ___coverage_array[4000] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_bool_ex(element, "isdst", tmp___13 + 1U,
                              ((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + (begin - 1U)))->isdst);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4001] == 0) {
              {
              fprintf(_coverage_fout, "4001\n");
              fflush(_coverage_fout);
              ___coverage_array[4001] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___14 = strlen("abbr");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4002] == 0) {
              {
              fprintf(_coverage_fout, "4002\n");
              fflush(_coverage_fout);
              ___coverage_array[4002] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_string_ex(element, "abbr", tmp___14 + 1U,
                                (tzobj->tzi.tz)->timezone_abbr + ((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + (begin - 1U)))->abbr_idx,
                                1);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4003] == 0) {
              {
              fprintf(_coverage_fout, "4003\n");
              fflush(_coverage_fout);
              ___coverage_array[4003] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_next_index_zval(return_value, element);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4007] == 0) {
              {
              fprintf(_coverage_fout, "4007\n");
              fflush(_coverage_fout);
              ___coverage_array[4007] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            while (1) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4004] == 0) {
                {
                fprintf(_coverage_fout, "4004\n");
                fflush(_coverage_fout);
                ___coverage_array[4004] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___15 = _emalloc(sizeof(zval_gc_info ));
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4005] == 0) {
                {
                fprintf(_coverage_fout, "4005\n");
                fflush(_coverage_fout);
                ___coverage_array[4005] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              element = (zval *)tmp___15;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4006] == 0) {
                {
                fprintf(_coverage_fout, "4006\n");
                fflush(_coverage_fout);
                ___coverage_array[4006] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
              break;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4008] == 0) {
              {
              fprintf(_coverage_fout, "4008\n");
              fflush(_coverage_fout);
              ___coverage_array[4008] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            element->refcount__gc = 1U;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4009] == 0) {
              {
              fprintf(_coverage_fout, "4009\n");
              fflush(_coverage_fout);
              ___coverage_array[4009] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            element->is_ref__gc = (unsigned char)0;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4010] == 0) {
              {
              fprintf(_coverage_fout, "4010\n");
              fflush(_coverage_fout);
              ___coverage_array[4010] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            _array_init(element, 0U);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4011] == 0) {
              {
              fprintf(_coverage_fout, "4011\n");
              fflush(_coverage_fout);
              ___coverage_array[4011] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___16 = strlen("ts");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4012] == 0) {
              {
              fprintf(_coverage_fout, "4012\n");
              fflush(_coverage_fout);
              ___coverage_array[4012] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_long_ex(element, "ts", tmp___16 + 1U, timestamp_begin);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___17 = php_format_date((char *)"Y-m-d\\TH:i:sO", 13,
                                       timestamp_begin, 0);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4014] == 0) {
              {
              fprintf(_coverage_fout, "4014\n");
              fflush(_coverage_fout);
              ___coverage_array[4014] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___18 = strlen("time");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4015] == 0) {
              {
              fprintf(_coverage_fout, "4015\n");
              fflush(_coverage_fout);
              ___coverage_array[4015] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_string_ex(element, "time", tmp___18 + 1U,
                                (char *)tmp___17, 0);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4016] == 0) {
              {
              fprintf(_coverage_fout, "4016\n");
              fflush(_coverage_fout);
              ___coverage_array[4016] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___19 = strlen("offset");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4017] == 0) {
              {
              fprintf(_coverage_fout, "4017\n");
              fflush(_coverage_fout);
              ___coverage_array[4017] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_long_ex(element, "offset", tmp___19 + 1U,
                              (long )((tzobj->tzi.tz)->type + 0)->offset);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___20 = strlen("isdst");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4019] == 0) {
              {
              fprintf(_coverage_fout, "4019\n");
              fflush(_coverage_fout);
              ___coverage_array[4019] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_bool_ex(element, "isdst", tmp___20 + 1U,
                              ((tzobj->tzi.tz)->type + 0)->isdst);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4020] == 0) {
              {
              fprintf(_coverage_fout, "4020\n");
              fflush(_coverage_fout);
              ___coverage_array[4020] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___21 = strlen("abbr");
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4021] == 0) {
              {
              fprintf(_coverage_fout, "4021\n");
              fflush(_coverage_fout);
              ___coverage_array[4021] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_assoc_string_ex(element, "abbr", tmp___21 + 1U,
                                (tzobj->tzi.tz)->timezone_abbr + ((tzobj->tzi.tz)->type + 0)->abbr_idx,
                                1);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4022] == 0) {
              {
              fprintf(_coverage_fout, "4022\n");
              fflush(_coverage_fout);
              ___coverage_array[4022] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_next_index_zval(return_value, element);
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4024] == 0) {
            {
            fprintf(_coverage_fout, "4024\n");
            fflush(_coverage_fout);
            ___coverage_array[4024] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          found = 1U;
          break;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4025] == 0) {
            {
            fprintf(_coverage_fout, "4025\n");
            fflush(_coverage_fout);
            ___coverage_array[4025] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4028] == 0) {
          {
          fprintf(_coverage_fout, "4028\n");
          fflush(_coverage_fout);
          ___coverage_array[4028] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        begin ++;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4029] == 0) {
          {
          fprintf(_coverage_fout, "4029\n");
          fflush(_coverage_fout);
          ___coverage_array[4029] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (begin < (tzobj->tzi.tz)->timecnt) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4026] == 0) {
            {
            fprintf(_coverage_fout, "4026\n");
            fflush(_coverage_fout);
            ___coverage_array[4026] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        } else {
          break;
        }
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4031] == 0) {
        {
        fprintf(_coverage_fout, "4031\n");
        fflush(_coverage_fout);
        ___coverage_array[4031] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4111] == 0) {
    {
    fprintf(_coverage_fout, "4111\n");
    fflush(_coverage_fout);
    ___coverage_array[4111] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! found) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4073] == 0) {
      {
      fprintf(_coverage_fout, "4073\n");
      fflush(_coverage_fout);
      ___coverage_array[4073] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((tzobj->tzi.tz)->timecnt > 0U) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4038] == 0) {
        {
        fprintf(_coverage_fout, "4038\n");
        fflush(_coverage_fout);
        ___coverage_array[4038] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___22 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4036] == 0) {
          {
          fprintf(_coverage_fout, "4036\n");
          fflush(_coverage_fout);
          ___coverage_array[4036] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        element = (zval *)tmp___22;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4037] == 0) {
          {
          fprintf(_coverage_fout, "4037\n");
          fflush(_coverage_fout);
          ___coverage_array[4037] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4039] == 0) {
        {
        fprintf(_coverage_fout, "4039\n");
        fflush(_coverage_fout);
        ___coverage_array[4039] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element->refcount__gc = 1U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4040] == 0) {
        {
        fprintf(_coverage_fout, "4040\n");
        fflush(_coverage_fout);
        ___coverage_array[4040] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element->is_ref__gc = (unsigned char)0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4041] == 0) {
        {
        fprintf(_coverage_fout, "4041\n");
        fflush(_coverage_fout);
        ___coverage_array[4041] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _array_init(element, 0U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4042] == 0) {
        {
        fprintf(_coverage_fout, "4042\n");
        fflush(_coverage_fout);
        ___coverage_array[4042] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___23 = strlen("ts");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4043] == 0) {
        {
        fprintf(_coverage_fout, "4043\n");
        fflush(_coverage_fout);
        ___coverage_array[4043] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(element, "ts", tmp___23 + 1U, timestamp_begin);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___24 = php_format_date((char *)"Y-m-d\\TH:i:sO", 13, timestamp_begin,
                                 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___25 = strlen("time");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4046] == 0) {
        {
        fprintf(_coverage_fout, "4046\n");
        fflush(_coverage_fout);
        ___coverage_array[4046] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(element, "time", tmp___25 + 1U, (char *)tmp___24, 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___26 = strlen("offset");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4048] == 0) {
        {
        fprintf(_coverage_fout, "4048\n");
        fflush(_coverage_fout);
        ___coverage_array[4048] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(element, "offset", tmp___26 + 1U,
                        (long )((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + ((tzobj->tzi.tz)->timecnt - 1U)))->offset);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___27 = strlen("isdst");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4050] == 0) {
        {
        fprintf(_coverage_fout, "4050\n");
        fflush(_coverage_fout);
        ___coverage_array[4050] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_bool_ex(element, "isdst", tmp___27 + 1U,
                        ((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + ((tzobj->tzi.tz)->timecnt - 1U)))->isdst);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4051] == 0) {
        {
        fprintf(_coverage_fout, "4051\n");
        fflush(_coverage_fout);
        ___coverage_array[4051] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___28 = strlen("abbr");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4052] == 0) {
        {
        fprintf(_coverage_fout, "4052\n");
        fflush(_coverage_fout);
        ___coverage_array[4052] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(element, "abbr", tmp___28 + 1U,
                          (tzobj->tzi.tz)->timezone_abbr + ((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + ((tzobj->tzi.tz)->timecnt - 1U)))->abbr_idx,
                          1);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4053] == 0) {
        {
        fprintf(_coverage_fout, "4053\n");
        fflush(_coverage_fout);
        ___coverage_array[4053] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_next_index_zval(return_value, element);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4057] == 0) {
        {
        fprintf(_coverage_fout, "4057\n");
        fflush(_coverage_fout);
        ___coverage_array[4057] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___29 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4055] == 0) {
          {
          fprintf(_coverage_fout, "4055\n");
          fflush(_coverage_fout);
          ___coverage_array[4055] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        element = (zval *)tmp___29;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4056] == 0) {
          {
          fprintf(_coverage_fout, "4056\n");
          fflush(_coverage_fout);
          ___coverage_array[4056] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4058] == 0) {
        {
        fprintf(_coverage_fout, "4058\n");
        fflush(_coverage_fout);
        ___coverage_array[4058] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element->refcount__gc = 1U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4059] == 0) {
        {
        fprintf(_coverage_fout, "4059\n");
        fflush(_coverage_fout);
        ___coverage_array[4059] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element->is_ref__gc = (unsigned char)0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4060] == 0) {
        {
        fprintf(_coverage_fout, "4060\n");
        fflush(_coverage_fout);
        ___coverage_array[4060] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _array_init(element, 0U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4061] == 0) {
        {
        fprintf(_coverage_fout, "4061\n");
        fflush(_coverage_fout);
        ___coverage_array[4061] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___30 = strlen("ts");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4062] == 0) {
        {
        fprintf(_coverage_fout, "4062\n");
        fflush(_coverage_fout);
        ___coverage_array[4062] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(element, "ts", tmp___30 + 1U, timestamp_begin);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___31 = php_format_date((char *)"Y-m-d\\TH:i:sO", 13, timestamp_begin,
                                 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___32 = strlen("time");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4065] == 0) {
        {
        fprintf(_coverage_fout, "4065\n");
        fflush(_coverage_fout);
        ___coverage_array[4065] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(element, "time", tmp___32 + 1U, (char *)tmp___31, 0);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4066] == 0) {
        {
        fprintf(_coverage_fout, "4066\n");
        fflush(_coverage_fout);
        ___coverage_array[4066] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___33 = strlen("offset");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4067] == 0) {
        {
        fprintf(_coverage_fout, "4067\n");
        fflush(_coverage_fout);
        ___coverage_array[4067] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_long_ex(element, "offset", tmp___33 + 1U,
                        (long )((tzobj->tzi.tz)->type + 0)->offset);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___34 = strlen("isdst");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4069] == 0) {
        {
        fprintf(_coverage_fout, "4069\n");
        fflush(_coverage_fout);
        ___coverage_array[4069] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_bool_ex(element, "isdst", tmp___34 + 1U,
                        ((tzobj->tzi.tz)->type + 0)->isdst);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___35 = strlen("abbr");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4071] == 0) {
        {
        fprintf(_coverage_fout, "4071\n");
        fflush(_coverage_fout);
        ___coverage_array[4071] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(element, "abbr", tmp___35 + 1U,
                          (tzobj->tzi.tz)->timezone_abbr + ((tzobj->tzi.tz)->type + 0)->abbr_idx,
                          1);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4072] == 0) {
        {
        fprintf(_coverage_fout, "4072\n");
        fflush(_coverage_fout);
        ___coverage_array[4072] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_next_index_zval(return_value, element);
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4098] == 0) {
      {
      fprintf(_coverage_fout, "4098\n");
      fflush(_coverage_fout);
      ___coverage_array[4098] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i = begin;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4099] == 0) {
      {
      fprintf(_coverage_fout, "4099\n");
      fflush(_coverage_fout);
      ___coverage_array[4099] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (i < (tzobj->tzi.tz)->timecnt) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4074] == 0) {
          {
          fprintf(_coverage_fout, "4074\n");
          fflush(_coverage_fout);
          ___coverage_array[4074] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      } else {
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4096] == 0) {
        {
        fprintf(_coverage_fout, "4096\n");
        fflush(_coverage_fout);
        ___coverage_array[4096] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((long )*((tzobj->tzi.tz)->trans + i) < timestamp_end) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4078] == 0) {
          {
          fprintf(_coverage_fout, "4078\n");
          fflush(_coverage_fout);
          ___coverage_array[4078] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4075] == 0) {
            {
            fprintf(_coverage_fout, "4075\n");
            fflush(_coverage_fout);
            ___coverage_array[4075] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___36 = _emalloc(sizeof(zval_gc_info ));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4076] == 0) {
            {
            fprintf(_coverage_fout, "4076\n");
            fflush(_coverage_fout);
            ___coverage_array[4076] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          element = (zval *)tmp___36;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4077] == 0) {
            {
            fprintf(_coverage_fout, "4077\n");
            fflush(_coverage_fout);
            ___coverage_array[4077] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4079] == 0) {
          {
          fprintf(_coverage_fout, "4079\n");
          fflush(_coverage_fout);
          ___coverage_array[4079] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        element->refcount__gc = 1U;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4080] == 0) {
          {
          fprintf(_coverage_fout, "4080\n");
          fflush(_coverage_fout);
          ___coverage_array[4080] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        element->is_ref__gc = (unsigned char)0;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4081] == 0) {
          {
          fprintf(_coverage_fout, "4081\n");
          fflush(_coverage_fout);
          ___coverage_array[4081] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _array_init(element, 0U);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4082] == 0) {
          {
          fprintf(_coverage_fout, "4082\n");
          fflush(_coverage_fout);
          ___coverage_array[4082] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___37 = strlen("ts");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4083] == 0) {
          {
          fprintf(_coverage_fout, "4083\n");
          fflush(_coverage_fout);
          ___coverage_array[4083] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_assoc_long_ex(element, "ts", tmp___37 + 1U,
                          (long )*((tzobj->tzi.tz)->trans + i));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___38 = php_format_date((char *)"Y-m-d\\TH:i:sO", 13,
                                   (long )*((tzobj->tzi.tz)->trans + i), 0);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___39 = strlen("time");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4086] == 0) {
          {
          fprintf(_coverage_fout, "4086\n");
          fflush(_coverage_fout);
          ___coverage_array[4086] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_assoc_string_ex(element, "time", tmp___39 + 1U, (char *)tmp___38, 0);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4087] == 0) {
          {
          fprintf(_coverage_fout, "4087\n");
          fflush(_coverage_fout);
          ___coverage_array[4087] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___40 = strlen("offset");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4088] == 0) {
          {
          fprintf(_coverage_fout, "4088\n");
          fflush(_coverage_fout);
          ___coverage_array[4088] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_assoc_long_ex(element, "offset", tmp___40 + 1U,
                          (long )((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + i))->offset);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4089] == 0) {
          {
          fprintf(_coverage_fout, "4089\n");
          fflush(_coverage_fout);
          ___coverage_array[4089] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___41 = strlen("isdst");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4090] == 0) {
          {
          fprintf(_coverage_fout, "4090\n");
          fflush(_coverage_fout);
          ___coverage_array[4090] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_assoc_bool_ex(element, "isdst", tmp___41 + 1U,
                          ((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + i))->isdst);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4091] == 0) {
          {
          fprintf(_coverage_fout, "4091\n");
          fflush(_coverage_fout);
          ___coverage_array[4091] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___42 = strlen("abbr");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4092] == 0) {
          {
          fprintf(_coverage_fout, "4092\n");
          fflush(_coverage_fout);
          ___coverage_array[4092] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_assoc_string_ex(element, "abbr", tmp___42 + 1U,
                            (tzobj->tzi.tz)->timezone_abbr + ((tzobj->tzi.tz)->type + *((tzobj->tzi.tz)->trans_idx + i))->abbr_idx,
                            1);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4093] == 0) {
          {
          fprintf(_coverage_fout, "4093\n");
          fflush(_coverage_fout);
          ___coverage_array[4093] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_next_index_zval(return_value, element);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4094] == 0) {
          {
          fprintf(_coverage_fout, "4094\n");
          fflush(_coverage_fout);
          ___coverage_array[4094] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4097] == 0) {
        {
        fprintf(_coverage_fout, "4097\n");
        fflush(_coverage_fout);
        ___coverage_array[4097] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      i ++;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4112] == 0) {
    {
    fprintf(_coverage_fout, "4112\n");
    fflush(_coverage_fout);
    ___coverage_array[4112] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_timezone_location_get(int ht , zval *return_value ,
                               zval **return_value_ptr , zval *this_ptr ,
                               int return_value_used ) 
{ zval *object ;
  php_timezone_obj *tzobj ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  size_t tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  size_t tmp___4 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4132] == 0) {
    {
    fprintf(_coverage_fout, "4132\n");
    fflush(_coverage_fout);
    ___coverage_array[4132] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_method_parameters(ht, this_ptr, "O", & object,
                                     date_ce_timezone);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4133] == 0) {
    {
    fprintf(_coverage_fout, "4133\n");
    fflush(_coverage_fout);
    ___coverage_array[4133] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4116] == 0) {
      {
      fprintf(_coverage_fout, "4116\n");
      fflush(_coverage_fout);
      ___coverage_array[4116] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4113] == 0) {
        {
        fprintf(_coverage_fout, "4113\n");
        fflush(_coverage_fout);
        ___coverage_array[4113] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4114] == 0) {
        {
        fprintf(_coverage_fout, "4114\n");
        fflush(_coverage_fout);
        ___coverage_array[4114] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4115] == 0) {
        {
        fprintf(_coverage_fout, "4115\n");
        fflush(_coverage_fout);
        ___coverage_array[4115] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4117] == 0) {
      {
      fprintf(_coverage_fout, "4117\n");
      fflush(_coverage_fout);
      ___coverage_array[4117] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4118] == 0) {
      {
      fprintf(_coverage_fout, "4118\n");
      fflush(_coverage_fout);
      ___coverage_array[4118] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4134] == 0) {
    {
    fprintf(_coverage_fout, "4134\n");
    fflush(_coverage_fout);
    ___coverage_array[4134] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4135] == 0) {
    {
    fprintf(_coverage_fout, "4135\n");
    fflush(_coverage_fout);
    ___coverage_array[4135] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzobj = (php_timezone_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4136] == 0) {
    {
    fprintf(_coverage_fout, "4136\n");
    fflush(_coverage_fout);
    ___coverage_array[4136] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! tzobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4122] == 0) {
      {
      fprintf(_coverage_fout, "4122\n");
      fflush(_coverage_fout);
      ___coverage_array[4122] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateTimeZone object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4123] == 0) {
      {
      fprintf(_coverage_fout, "4123\n");
      fflush(_coverage_fout);
      ___coverage_array[4123] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4119] == 0) {
        {
        fprintf(_coverage_fout, "4119\n");
        fflush(_coverage_fout);
        ___coverage_array[4119] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4120] == 0) {
        {
        fprintf(_coverage_fout, "4120\n");
        fflush(_coverage_fout);
        ___coverage_array[4120] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4121] == 0) {
        {
        fprintf(_coverage_fout, "4121\n");
        fflush(_coverage_fout);
        ___coverage_array[4121] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4124] == 0) {
      {
      fprintf(_coverage_fout, "4124\n");
      fflush(_coverage_fout);
      ___coverage_array[4124] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4125] == 0) {
      {
      fprintf(_coverage_fout, "4125\n");
      fflush(_coverage_fout);
      ___coverage_array[4125] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4137] == 0) {
    {
    fprintf(_coverage_fout, "4137\n");
    fflush(_coverage_fout);
    ___coverage_array[4137] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tzobj->type != 3) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4129] == 0) {
      {
      fprintf(_coverage_fout, "4129\n");
      fflush(_coverage_fout);
      ___coverage_array[4129] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4126] == 0) {
        {
        fprintf(_coverage_fout, "4126\n");
        fflush(_coverage_fout);
        ___coverage_array[4126] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4127] == 0) {
        {
        fprintf(_coverage_fout, "4127\n");
        fflush(_coverage_fout);
        ___coverage_array[4127] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4128] == 0) {
        {
        fprintf(_coverage_fout, "4128\n");
        fflush(_coverage_fout);
        ___coverage_array[4128] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___1->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4130] == 0) {
      {
      fprintf(_coverage_fout, "4130\n");
      fflush(_coverage_fout);
      ___coverage_array[4130] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4131] == 0) {
      {
      fprintf(_coverage_fout, "4131\n");
      fflush(_coverage_fout);
      ___coverage_array[4131] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4138] == 0) {
    {
    fprintf(_coverage_fout, "4138\n");
    fflush(_coverage_fout);
    ___coverage_array[4138] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4139] == 0) {
    {
    fprintf(_coverage_fout, "4139\n");
    fflush(_coverage_fout);
    ___coverage_array[4139] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = strlen("country_code");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4140] == 0) {
    {
    fprintf(_coverage_fout, "4140\n");
    fflush(_coverage_fout);
    ___coverage_array[4140] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_string_ex(return_value, "country_code", tmp___1 + 1U,
                      (tzobj->tzi.tz)->location.country_code, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4141] == 0) {
    {
    fprintf(_coverage_fout, "4141\n");
    fflush(_coverage_fout);
    ___coverage_array[4141] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = strlen("latitude");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4142] == 0) {
    {
    fprintf(_coverage_fout, "4142\n");
    fflush(_coverage_fout);
    ___coverage_array[4142] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_double_ex(return_value, "latitude", tmp___2 + 1U,
                      (tzobj->tzi.tz)->location.latitude);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4143] == 0) {
    {
    fprintf(_coverage_fout, "4143\n");
    fflush(_coverage_fout);
    ___coverage_array[4143] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = strlen("longitude");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4144] == 0) {
    {
    fprintf(_coverage_fout, "4144\n");
    fflush(_coverage_fout);
    ___coverage_array[4144] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_double_ex(return_value, "longitude", tmp___3 + 1U,
                      (tzobj->tzi.tz)->location.longitude);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___4 = strlen("comments");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4146] == 0) {
    {
    fprintf(_coverage_fout, "4146\n");
    fflush(_coverage_fout);
    ___coverage_array[4146] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_string_ex(return_value, "comments", tmp___4 + 1U,
                      (tzobj->tzi.tz)->location.comments, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4147] == 0) {
    {
    fprintf(_coverage_fout, "4147\n");
    fflush(_coverage_fout);
    ___coverage_array[4147] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int date_interval_initialize(timelib_rel_time **rt , char *format ,
                                    int format_length ) 
{ timelib_time *b ;
  timelib_time *e ;
  timelib_rel_time *p ;
  int r ;
  int retval ;
  struct timelib_error_container *errors ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4163] == 0) {
    {
    fprintf(_coverage_fout, "4163\n");
    fflush(_coverage_fout);
    ___coverage_array[4163] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  b = (timelib_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4164] == 0) {
    {
    fprintf(_coverage_fout, "4164\n");
    fflush(_coverage_fout);
    ___coverage_array[4164] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  e = (timelib_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4165] == 0) {
    {
    fprintf(_coverage_fout, "4165\n");
    fflush(_coverage_fout);
    ___coverage_array[4165] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = (timelib_rel_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4166] == 0) {
    {
    fprintf(_coverage_fout, "4166\n");
    fflush(_coverage_fout);
    ___coverage_array[4166] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  r = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4167] == 0) {
    {
    fprintf(_coverage_fout, "4167\n");
    fflush(_coverage_fout);
    ___coverage_array[4167] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4168] == 0) {
    {
    fprintf(_coverage_fout, "4168\n");
    fflush(_coverage_fout);
    ___coverage_array[4168] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_strtointerval(format, format_length, & b, & e, & p, & r, & errors);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4169] == 0) {
    {
    fprintf(_coverage_fout, "4169\n");
    fflush(_coverage_fout);
    ___coverage_array[4169] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (errors->error_count > 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4148] == 0) {
      {
      fprintf(_coverage_fout, "4148\n");
      fflush(_coverage_fout);
      ___coverage_array[4148] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Unknown or bad format (%s)", format);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4149] == 0) {
      {
      fprintf(_coverage_fout, "4149\n");
      fflush(_coverage_fout);
      ___coverage_array[4149] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval = -1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4162] == 0) {
      {
      fprintf(_coverage_fout, "4162\n");
      fflush(_coverage_fout);
      ___coverage_array[4162] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (p) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4150] == 0) {
        {
        fprintf(_coverage_fout, "4150\n");
        fflush(_coverage_fout);
        ___coverage_array[4150] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *rt = p;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4151] == 0) {
        {
        fprintf(_coverage_fout, "4151\n");
        fflush(_coverage_fout);
        ___coverage_array[4151] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      retval = 0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (b) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (e) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4152] == 0) {
            {
            fprintf(_coverage_fout, "4152\n");
            fflush(_coverage_fout);
            ___coverage_array[4152] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          timelib_update_ts(b, (timelib_tzinfo *)((void *)0));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4153] == 0) {
            {
            fprintf(_coverage_fout, "4153\n");
            fflush(_coverage_fout);
            ___coverage_array[4153] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          timelib_update_ts(e, (timelib_tzinfo *)((void *)0));
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4154] == 0) {
            {
            fprintf(_coverage_fout, "4154\n");
            fflush(_coverage_fout);
            ___coverage_array[4154] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *rt = timelib_diff(b, e);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4155] == 0) {
            {
            fprintf(_coverage_fout, "4155\n");
            fflush(_coverage_fout);
            ___coverage_array[4155] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          retval = 0;
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4156] == 0) {
            {
            fprintf(_coverage_fout, "4156\n");
            fflush(_coverage_fout);
            ___coverage_array[4156] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          php_error_docref0((char const   *)((void *)0), 1 << 1L,
                            "Failed to parse interval (%s)", format);
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4157] == 0) {
            {
            fprintf(_coverage_fout, "4157\n");
            fflush(_coverage_fout);
            ___coverage_array[4157] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          retval = -1;
        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4159] == 0) {
          {
          fprintf(_coverage_fout, "4159\n");
          fflush(_coverage_fout);
          ___coverage_array[4159] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Failed to parse interval (%s)", format);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4160] == 0) {
          {
          fprintf(_coverage_fout, "4160\n");
          fflush(_coverage_fout);
          ___coverage_array[4160] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        retval = -1;
      }
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4170] == 0) {
    {
    fprintf(_coverage_fout, "4170\n");
    fflush(_coverage_fout);
    ___coverage_array[4170] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_error_container_dtor(errors);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4171] == 0) {
    {
    fprintf(_coverage_fout, "4171\n");
    fflush(_coverage_fout);
    ___coverage_array[4171] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
zval *date_interval_read_property(zval *object , zval *member , int type ,
                                  zend_literal const   *key ) 
{ php_interval_obj *obj ;
  zval *retval ;
  zval tmp_member ;
  timelib_sll value ;
  zend_object __attribute__((__visibility__("default")))  *tmp ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___3 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;
  size_t __s1_len___0 ;
  size_t __s2_len___0 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  unsigned char const   *__s2___0 ;
  register int __result___1 ;
  int tmp___10 ;
  unsigned char const   *__s1___0 ;
  register int __result___2 ;
  int tmp___11 ;
  int tmp___12 ;
  int tmp___13 ;
  size_t __s1_len___1 ;
  size_t __s2_len___1 ;
  int tmp___14 ;
  int tmp___15 ;
  int tmp___16 ;
  unsigned char const   *__s2___1 ;
  register int __result___3 ;
  int tmp___17 ;
  unsigned char const   *__s1___1 ;
  register int __result___4 ;
  int tmp___18 ;
  int tmp___19 ;
  int tmp___20 ;
  size_t __s1_len___2 ;
  size_t __s2_len___2 ;
  int tmp___21 ;
  int tmp___22 ;
  int tmp___23 ;
  unsigned char const   *__s2___2 ;
  register int __result___5 ;
  int tmp___24 ;
  unsigned char const   *__s1___2 ;
  register int __result___6 ;
  int tmp___25 ;
  int tmp___26 ;
  int tmp___27 ;
  size_t __s1_len___3 ;
  size_t __s2_len___3 ;
  int tmp___28 ;
  int tmp___29 ;
  int tmp___30 ;
  unsigned char const   *__s2___3 ;
  register int __result___7 ;
  int tmp___31 ;
  unsigned char const   *__s1___3 ;
  register int __result___8 ;
  int tmp___32 ;
  int tmp___33 ;
  int tmp___34 ;
  size_t __s1_len___4 ;
  size_t __s2_len___4 ;
  int tmp___35 ;
  int tmp___36 ;
  int tmp___37 ;
  unsigned char const   *__s2___4 ;
  register int __result___9 ;
  int tmp___38 ;
  unsigned char const   *__s1___4 ;
  register int __result___10 ;
  int tmp___39 ;
  int tmp___40 ;
  int tmp___41 ;
  size_t __s1_len___5 ;
  size_t __s2_len___5 ;
  int tmp___42 ;
  int tmp___43 ;
  int tmp___44 ;
  unsigned char const   *__s2___5 ;
  register int __result___11 ;
  int tmp___45 ;
  unsigned char const   *__s1___5 ;
  register int __result___12 ;
  int tmp___46 ;
  int tmp___47 ;
  int tmp___48 ;
  size_t __s1_len___6 ;
  size_t __s2_len___6 ;
  int tmp___49 ;
  int tmp___50 ;
  int tmp___51 ;
  unsigned char const   *__s2___6 ;
  register int __result___13 ;
  int tmp___52 ;
  unsigned char const   *__s1___6 ;
  register int __result___14 ;
  int tmp___53 ;
  int tmp___54 ;
  int tmp___55 ;
  zend_object_handlers __attribute__((__visibility__("default")))  *tmp___56 ;
  void __attribute__((__visibility__("default")))  *tmp___57 ;
  zval *__z ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4358] == 0) {
    {
    fprintf(_coverage_fout, "4358\n");
    fflush(_coverage_fout);
    ___coverage_array[4358] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  value = (timelib_sll )-1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4359] == 0) {
    {
    fprintf(_coverage_fout, "4359\n");
    fflush(_coverage_fout);
    ___coverage_array[4359] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )member->type != 6) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4174] == 0) {
      {
      fprintf(_coverage_fout, "4174\n");
      fflush(_coverage_fout);
      ___coverage_array[4174] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4175] == 0) {
      {
      fprintf(_coverage_fout, "4175\n");
      fflush(_coverage_fout);
      ___coverage_array[4175] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(& tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4176] == 0) {
      {
      fprintf(_coverage_fout, "4176\n");
      fflush(_coverage_fout);
      ___coverage_array[4176] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )tmp_member.type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4172] == 0) {
        {
        fprintf(_coverage_fout, "4172\n");
        fflush(_coverage_fout);
        ___coverage_array[4172] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(& tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4173] == 0) {
        {
        fprintf(_coverage_fout, "4173\n");
        fflush(_coverage_fout);
        ___coverage_array[4173] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4177] == 0) {
      {
      fprintf(_coverage_fout, "4177\n");
      fflush(_coverage_fout);
      ___coverage_array[4177] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = & tmp_member;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4178] == 0) {
      {
      fprintf(_coverage_fout, "4178\n");
      fflush(_coverage_fout);
      ___coverage_array[4178] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4360] == 0) {
    {
    fprintf(_coverage_fout, "4360\n");
    fflush(_coverage_fout);
    ___coverage_array[4360] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_objects_get_address((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4361] == 0) {
    {
    fprintf(_coverage_fout, "4361\n");
    fflush(_coverage_fout);
    ___coverage_array[4361] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  obj = (php_interval_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4362] == 0) {
    {
    fprintf(_coverage_fout, "4362\n");
    fflush(_coverage_fout);
    ___coverage_array[4362] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4333] == 0) {
      {
      fprintf(_coverage_fout, "4333\n");
      fflush(_coverage_fout);
      ___coverage_array[4333] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4190] == 0) {
        {
        fprintf(_coverage_fout, "4190\n");
        fflush(_coverage_fout);
        ___coverage_array[4190] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4191] == 0) {
        {
        fprintf(_coverage_fout, "4191\n");
        fflush(_coverage_fout);
        ___coverage_array[4191] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len = strlen("y");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4185] == 0) {
          {
          fprintf(_coverage_fout, "4185\n");
          fflush(_coverage_fout);
          ___coverage_array[4185] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4183] == 0) {
            {
            fprintf(_coverage_fout, "4183\n");
            fflush(_coverage_fout);
            ___coverage_array[4183] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___0: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("y" + 1)) - (unsigned int )((void const   *)"y") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4179] == 0) {
              {
              fprintf(_coverage_fout, "4179\n");
              fflush(_coverage_fout);
              ___coverage_array[4179] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___6 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4182] == 0) {
              {
              fprintf(_coverage_fout, "4182\n");
              fflush(_coverage_fout);
              ___coverage_array[4182] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4180] == 0) {
                {
                fprintf(_coverage_fout, "4180\n");
                fflush(_coverage_fout);
                ___coverage_array[4180] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___6 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4181] == 0) {
                {
                fprintf(_coverage_fout, "4181\n");
                fflush(_coverage_fout);
                ___coverage_array[4181] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___6 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___6 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4193] == 0) {
        {
        fprintf(_coverage_fout, "4193\n");
        fflush(_coverage_fout);
        ___coverage_array[4193] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___6) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4186] == 0) {
          {
          fprintf(_coverage_fout, "4186\n");
          fflush(_coverage_fout);
          ___coverage_array[4186] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_strcmp((char const   *)member->value.str.val, "y");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4187] == 0) {
          {
          fprintf(_coverage_fout, "4187\n");
          fflush(_coverage_fout);
          ___coverage_array[4187] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = tmp___1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4188] == 0) {
          {
          fprintf(_coverage_fout, "4188\n");
          fflush(_coverage_fout);
          ___coverage_array[4188] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___4 = __builtin_strcmp((char const   *)member->value.str.val, "y");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4189] == 0) {
          {
          fprintf(_coverage_fout, "4189\n");
          fflush(_coverage_fout);
          ___coverage_array[4189] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = tmp___4;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4194] == 0) {
        {
        fprintf(_coverage_fout, "4194\n");
        fflush(_coverage_fout);
        ___coverage_array[4194] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = __builtin_strcmp((char const   *)member->value.str.val, "y");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4195] == 0) {
        {
        fprintf(_coverage_fout, "4195\n");
        fflush(_coverage_fout);
        ___coverage_array[4195] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = tmp___4;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___5 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4196] == 0) {
        {
        fprintf(_coverage_fout, "4196\n");
        fflush(_coverage_fout);
        ___coverage_array[4196] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->y;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4197] == 0) {
        {
        fprintf(_coverage_fout, "4197\n");
        fflush(_coverage_fout);
        ___coverage_array[4197] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4209] == 0) {
        {
        fprintf(_coverage_fout, "4209\n");
        fflush(_coverage_fout);
        ___coverage_array[4209] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___0 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4210] == 0) {
        {
        fprintf(_coverage_fout, "4210\n");
        fflush(_coverage_fout);
        ___coverage_array[4210] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___0 = strlen("m");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4211] == 0) {
        {
        fprintf(_coverage_fout, "4211\n");
        fflush(_coverage_fout);
        ___coverage_array[4211] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___2;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (__s1_len___0 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4202] == 0) {
            {
            fprintf(_coverage_fout, "4202\n");
            fflush(_coverage_fout);
            ___coverage_array[4202] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___2: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("m" + 1)) - (unsigned int )((void const   *)"m") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4198] == 0) {
              {
              fprintf(_coverage_fout, "4198\n");
              fflush(_coverage_fout);
              ___coverage_array[4198] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___13 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4201] == 0) {
              {
              fprintf(_coverage_fout, "4201\n");
              fflush(_coverage_fout);
              ___coverage_array[4201] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___0 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4199] == 0) {
                {
                fprintf(_coverage_fout, "4199\n");
                fflush(_coverage_fout);
                ___coverage_array[4199] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___13 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4200] == 0) {
                {
                fprintf(_coverage_fout, "4200\n");
                fflush(_coverage_fout);
                ___coverage_array[4200] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___13 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4203] == 0) {
            {
            fprintf(_coverage_fout, "4203\n");
            fflush(_coverage_fout);
            ___coverage_array[4203] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___13 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___13) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___8 = __builtin_strcmp((char const   *)member->value.str.val, "m");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4206] == 0) {
          {
          fprintf(_coverage_fout, "4206\n");
          fflush(_coverage_fout);
          ___coverage_array[4206] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___12 = tmp___8;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4207] == 0) {
          {
          fprintf(_coverage_fout, "4207\n");
          fflush(_coverage_fout);
          ___coverage_array[4207] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___11 = __builtin_strcmp((char const   *)member->value.str.val, "m");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4208] == 0) {
          {
          fprintf(_coverage_fout, "4208\n");
          fflush(_coverage_fout);
          ___coverage_array[4208] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___12 = tmp___11;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4213] == 0) {
        {
        fprintf(_coverage_fout, "4213\n");
        fflush(_coverage_fout);
        ___coverage_array[4213] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___11 = __builtin_strcmp((char const   *)member->value.str.val, "m");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4214] == 0) {
        {
        fprintf(_coverage_fout, "4214\n");
        fflush(_coverage_fout);
        ___coverage_array[4214] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___12 = tmp___11;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4336] == 0) {
      {
      fprintf(_coverage_fout, "4336\n");
      fflush(_coverage_fout);
      ___coverage_array[4336] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___12 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4215] == 0) {
        {
        fprintf(_coverage_fout, "4215\n");
        fflush(_coverage_fout);
        ___coverage_array[4215] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->m;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4216] == 0) {
        {
        fprintf(_coverage_fout, "4216\n");
        fflush(_coverage_fout);
        ___coverage_array[4216] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4337] == 0) {
      {
      fprintf(_coverage_fout, "4337\n");
      fflush(_coverage_fout);
      ___coverage_array[4337] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4228] == 0) {
        {
        fprintf(_coverage_fout, "4228\n");
        fflush(_coverage_fout);
        ___coverage_array[4228] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___1 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4229] == 0) {
        {
        fprintf(_coverage_fout, "4229\n");
        fflush(_coverage_fout);
        ___coverage_array[4229] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___1 = strlen("d");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4230] == 0) {
        {
        fprintf(_coverage_fout, "4230\n");
        fflush(_coverage_fout);
        ___coverage_array[4230] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___4;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4223] == 0) {
          {
          fprintf(_coverage_fout, "4223\n");
          fflush(_coverage_fout);
          ___coverage_array[4223] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___1 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4221] == 0) {
            {
            fprintf(_coverage_fout, "4221\n");
            fflush(_coverage_fout);
            ___coverage_array[4221] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___4: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("d" + 1)) - (unsigned int )((void const   *)"d") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4217] == 0) {
              {
              fprintf(_coverage_fout, "4217\n");
              fflush(_coverage_fout);
              ___coverage_array[4217] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___20 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4220] == 0) {
              {
              fprintf(_coverage_fout, "4220\n");
              fflush(_coverage_fout);
              ___coverage_array[4220] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___1 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4218] == 0) {
                {
                fprintf(_coverage_fout, "4218\n");
                fflush(_coverage_fout);
                ___coverage_array[4218] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___20 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4219] == 0) {
                {
                fprintf(_coverage_fout, "4219\n");
                fflush(_coverage_fout);
                ___coverage_array[4219] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___20 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4222] == 0) {
            {
            fprintf(_coverage_fout, "4222\n");
            fflush(_coverage_fout);
            ___coverage_array[4222] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___20 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___20) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4224] == 0) {
          {
          fprintf(_coverage_fout, "4224\n");
          fflush(_coverage_fout);
          ___coverage_array[4224] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___15 = __builtin_strcmp((char const   *)member->value.str.val, "d");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4225] == 0) {
          {
          fprintf(_coverage_fout, "4225\n");
          fflush(_coverage_fout);
          ___coverage_array[4225] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___19 = tmp___15;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4226] == 0) {
          {
          fprintf(_coverage_fout, "4226\n");
          fflush(_coverage_fout);
          ___coverage_array[4226] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___18 = __builtin_strcmp((char const   *)member->value.str.val, "d");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4227] == 0) {
          {
          fprintf(_coverage_fout, "4227\n");
          fflush(_coverage_fout);
          ___coverage_array[4227] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___19 = tmp___18;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4232] == 0) {
        {
        fprintf(_coverage_fout, "4232\n");
        fflush(_coverage_fout);
        ___coverage_array[4232] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___18 = __builtin_strcmp((char const   *)member->value.str.val, "d");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4233] == 0) {
        {
        fprintf(_coverage_fout, "4233\n");
        fflush(_coverage_fout);
        ___coverage_array[4233] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___19 = tmp___18;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4338] == 0) {
      {
      fprintf(_coverage_fout, "4338\n");
      fflush(_coverage_fout);
      ___coverage_array[4338] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___19 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4234] == 0) {
        {
        fprintf(_coverage_fout, "4234\n");
        fflush(_coverage_fout);
        ___coverage_array[4234] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->d;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4235] == 0) {
        {
        fprintf(_coverage_fout, "4235\n");
        fflush(_coverage_fout);
        ___coverage_array[4235] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4339] == 0) {
      {
      fprintf(_coverage_fout, "4339\n");
      fflush(_coverage_fout);
      ___coverage_array[4339] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4247] == 0) {
        {
        fprintf(_coverage_fout, "4247\n");
        fflush(_coverage_fout);
        ___coverage_array[4247] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___2 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4248] == 0) {
        {
        fprintf(_coverage_fout, "4248\n");
        fflush(_coverage_fout);
        ___coverage_array[4248] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___2 = strlen("h");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4249] == 0) {
        {
        fprintf(_coverage_fout, "4249\n");
        fflush(_coverage_fout);
        ___coverage_array[4249] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___6;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (__s1_len___2 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4240] == 0) {
            {
            fprintf(_coverage_fout, "4240\n");
            fflush(_coverage_fout);
            ___coverage_array[4240] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___6: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("h" + 1)) - (unsigned int )((void const   *)"h") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4236] == 0) {
              {
              fprintf(_coverage_fout, "4236\n");
              fflush(_coverage_fout);
              ___coverage_array[4236] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___27 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (__s2_len___2 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4237] == 0) {
                {
                fprintf(_coverage_fout, "4237\n");
                fflush(_coverage_fout);
                ___coverage_array[4237] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___27 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4238] == 0) {
                {
                fprintf(_coverage_fout, "4238\n");
                fflush(_coverage_fout);
                ___coverage_array[4238] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___27 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4241] == 0) {
            {
            fprintf(_coverage_fout, "4241\n");
            fflush(_coverage_fout);
            ___coverage_array[4241] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___27 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4250] == 0) {
        {
        fprintf(_coverage_fout, "4250\n");
        fflush(_coverage_fout);
        ___coverage_array[4250] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___27) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4243] == 0) {
          {
          fprintf(_coverage_fout, "4243\n");
          fflush(_coverage_fout);
          ___coverage_array[4243] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___22 = __builtin_strcmp((char const   *)member->value.str.val, "h");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___26 = tmp___22;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4245] == 0) {
          {
          fprintf(_coverage_fout, "4245\n");
          fflush(_coverage_fout);
          ___coverage_array[4245] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___25 = __builtin_strcmp((char const   *)member->value.str.val, "h");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4246] == 0) {
          {
          fprintf(_coverage_fout, "4246\n");
          fflush(_coverage_fout);
          ___coverage_array[4246] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___26 = tmp___25;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4251] == 0) {
        {
        fprintf(_coverage_fout, "4251\n");
        fflush(_coverage_fout);
        ___coverage_array[4251] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___25 = __builtin_strcmp((char const   *)member->value.str.val, "h");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4252] == 0) {
        {
        fprintf(_coverage_fout, "4252\n");
        fflush(_coverage_fout);
        ___coverage_array[4252] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___26 = tmp___25;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4340] == 0) {
      {
      fprintf(_coverage_fout, "4340\n");
      fflush(_coverage_fout);
      ___coverage_array[4340] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___26 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4253] == 0) {
        {
        fprintf(_coverage_fout, "4253\n");
        fflush(_coverage_fout);
        ___coverage_array[4253] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->h;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4254] == 0) {
        {
        fprintf(_coverage_fout, "4254\n");
        fflush(_coverage_fout);
        ___coverage_array[4254] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4341] == 0) {
      {
      fprintf(_coverage_fout, "4341\n");
      fflush(_coverage_fout);
      ___coverage_array[4341] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4266] == 0) {
        {
        fprintf(_coverage_fout, "4266\n");
        fflush(_coverage_fout);
        ___coverage_array[4266] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___3 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4267] == 0) {
        {
        fprintf(_coverage_fout, "4267\n");
        fflush(_coverage_fout);
        ___coverage_array[4267] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___3 = strlen("i");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___8;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4261] == 0) {
          {
          fprintf(_coverage_fout, "4261\n");
          fflush(_coverage_fout);
          ___coverage_array[4261] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___3 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4259] == 0) {
            {
            fprintf(_coverage_fout, "4259\n");
            fflush(_coverage_fout);
            ___coverage_array[4259] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___8: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("i" + 1)) - (unsigned int )((void const   *)"i") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___34 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4258] == 0) {
              {
              fprintf(_coverage_fout, "4258\n");
              fflush(_coverage_fout);
              ___coverage_array[4258] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___3 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4256] == 0) {
                {
                fprintf(_coverage_fout, "4256\n");
                fflush(_coverage_fout);
                ___coverage_array[4256] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___34 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4257] == 0) {
                {
                fprintf(_coverage_fout, "4257\n");
                fflush(_coverage_fout);
                ___coverage_array[4257] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___34 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___34 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4269] == 0) {
        {
        fprintf(_coverage_fout, "4269\n");
        fflush(_coverage_fout);
        ___coverage_array[4269] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___34) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___29 = __builtin_strcmp((char const   *)member->value.str.val, "i");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4263] == 0) {
          {
          fprintf(_coverage_fout, "4263\n");
          fflush(_coverage_fout);
          ___coverage_array[4263] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___33 = tmp___29;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4264] == 0) {
          {
          fprintf(_coverage_fout, "4264\n");
          fflush(_coverage_fout);
          ___coverage_array[4264] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___32 = __builtin_strcmp((char const   *)member->value.str.val, "i");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4265] == 0) {
          {
          fprintf(_coverage_fout, "4265\n");
          fflush(_coverage_fout);
          ___coverage_array[4265] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___33 = tmp___32;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4270] == 0) {
        {
        fprintf(_coverage_fout, "4270\n");
        fflush(_coverage_fout);
        ___coverage_array[4270] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___32 = __builtin_strcmp((char const   *)member->value.str.val, "i");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4271] == 0) {
        {
        fprintf(_coverage_fout, "4271\n");
        fflush(_coverage_fout);
        ___coverage_array[4271] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___33 = tmp___32;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4342] == 0) {
      {
      fprintf(_coverage_fout, "4342\n");
      fflush(_coverage_fout);
      ___coverage_array[4342] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___33 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4272] == 0) {
        {
        fprintf(_coverage_fout, "4272\n");
        fflush(_coverage_fout);
        ___coverage_array[4272] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->i;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4273] == 0) {
        {
        fprintf(_coverage_fout, "4273\n");
        fflush(_coverage_fout);
        ___coverage_array[4273] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4343] == 0) {
      {
      fprintf(_coverage_fout, "4343\n");
      fflush(_coverage_fout);
      ___coverage_array[4343] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4285] == 0) {
        {
        fprintf(_coverage_fout, "4285\n");
        fflush(_coverage_fout);
        ___coverage_array[4285] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___4 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4286] == 0) {
        {
        fprintf(_coverage_fout, "4286\n");
        fflush(_coverage_fout);
        ___coverage_array[4286] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___4 = strlen("s");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___10;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4280] == 0) {
          {
          fprintf(_coverage_fout, "4280\n");
          fflush(_coverage_fout);
          ___coverage_array[4280] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___4 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4278] == 0) {
            {
            fprintf(_coverage_fout, "4278\n");
            fflush(_coverage_fout);
            ___coverage_array[4278] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___10: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("s" + 1)) - (unsigned int )((void const   *)"s") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___41 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4277] == 0) {
              {
              fprintf(_coverage_fout, "4277\n");
              fflush(_coverage_fout);
              ___coverage_array[4277] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___4 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4275] == 0) {
                {
                fprintf(_coverage_fout, "4275\n");
                fflush(_coverage_fout);
                ___coverage_array[4275] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___41 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4276] == 0) {
                {
                fprintf(_coverage_fout, "4276\n");
                fflush(_coverage_fout);
                ___coverage_array[4276] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___41 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4279] == 0) {
            {
            fprintf(_coverage_fout, "4279\n");
            fflush(_coverage_fout);
            ___coverage_array[4279] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___41 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4288] == 0) {
        {
        fprintf(_coverage_fout, "4288\n");
        fflush(_coverage_fout);
        ___coverage_array[4288] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___41) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4281] == 0) {
          {
          fprintf(_coverage_fout, "4281\n");
          fflush(_coverage_fout);
          ___coverage_array[4281] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___36 = __builtin_strcmp((char const   *)member->value.str.val, "s");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4282] == 0) {
          {
          fprintf(_coverage_fout, "4282\n");
          fflush(_coverage_fout);
          ___coverage_array[4282] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___40 = tmp___36;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___39 = __builtin_strcmp((char const   *)member->value.str.val, "s");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4284] == 0) {
          {
          fprintf(_coverage_fout, "4284\n");
          fflush(_coverage_fout);
          ___coverage_array[4284] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___40 = tmp___39;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4289] == 0) {
        {
        fprintf(_coverage_fout, "4289\n");
        fflush(_coverage_fout);
        ___coverage_array[4289] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___39 = __builtin_strcmp((char const   *)member->value.str.val, "s");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4290] == 0) {
        {
        fprintf(_coverage_fout, "4290\n");
        fflush(_coverage_fout);
        ___coverage_array[4290] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___40 = tmp___39;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4344] == 0) {
      {
      fprintf(_coverage_fout, "4344\n");
      fflush(_coverage_fout);
      ___coverage_array[4344] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___40 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4291] == 0) {
        {
        fprintf(_coverage_fout, "4291\n");
        fflush(_coverage_fout);
        ___coverage_array[4291] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->s;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4292] == 0) {
        {
        fprintf(_coverage_fout, "4292\n");
        fflush(_coverage_fout);
        ___coverage_array[4292] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4345] == 0) {
      {
      fprintf(_coverage_fout, "4345\n");
      fflush(_coverage_fout);
      ___coverage_array[4345] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4304] == 0) {
        {
        fprintf(_coverage_fout, "4304\n");
        fflush(_coverage_fout);
        ___coverage_array[4304] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___5 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4305] == 0) {
        {
        fprintf(_coverage_fout, "4305\n");
        fflush(_coverage_fout);
        ___coverage_array[4305] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___5 = strlen("invert");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4306] == 0) {
        {
        fprintf(_coverage_fout, "4306\n");
        fflush(_coverage_fout);
        ___coverage_array[4306] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___12;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4299] == 0) {
          {
          fprintf(_coverage_fout, "4299\n");
          fflush(_coverage_fout);
          ___coverage_array[4299] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___5 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4297] == 0) {
            {
            fprintf(_coverage_fout, "4297\n");
            fflush(_coverage_fout);
            ___coverage_array[4297] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___12: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("invert" + 1)) - (unsigned int )((void const   *)"invert") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4293] == 0) {
              {
              fprintf(_coverage_fout, "4293\n");
              fflush(_coverage_fout);
              ___coverage_array[4293] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___48 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (__s2_len___5 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___48 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4295] == 0) {
                {
                fprintf(_coverage_fout, "4295\n");
                fflush(_coverage_fout);
                ___coverage_array[4295] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___48 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4298] == 0) {
            {
            fprintf(_coverage_fout, "4298\n");
            fflush(_coverage_fout);
            ___coverage_array[4298] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___48 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4300] == 0) {
          {
          fprintf(_coverage_fout, "4300\n");
          fflush(_coverage_fout);
          ___coverage_array[4300] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___43 = __builtin_strcmp((char const   *)member->value.str.val,
                                    "invert");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___47 = tmp___43;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4302] == 0) {
          {
          fprintf(_coverage_fout, "4302\n");
          fflush(_coverage_fout);
          ___coverage_array[4302] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___46 = __builtin_strcmp((char const   *)member->value.str.val,
                                    "invert");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4303] == 0) {
          {
          fprintf(_coverage_fout, "4303\n");
          fflush(_coverage_fout);
          ___coverage_array[4303] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___47 = tmp___46;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4308] == 0) {
        {
        fprintf(_coverage_fout, "4308\n");
        fflush(_coverage_fout);
        ___coverage_array[4308] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___46 = __builtin_strcmp((char const   *)member->value.str.val,
                                  "invert");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4309] == 0) {
        {
        fprintf(_coverage_fout, "4309\n");
        fflush(_coverage_fout);
        ___coverage_array[4309] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___47 = tmp___46;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4346] == 0) {
      {
      fprintf(_coverage_fout, "4346\n");
      fflush(_coverage_fout);
      ___coverage_array[4346] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___47 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4310] == 0) {
        {
        fprintf(_coverage_fout, "4310\n");
        fflush(_coverage_fout);
        ___coverage_array[4310] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (long long )(obj->diff)->invert;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4311] == 0) {
        {
        fprintf(_coverage_fout, "4311\n");
        fflush(_coverage_fout);
        ___coverage_array[4311] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4347] == 0) {
      {
      fprintf(_coverage_fout, "4347\n");
      fflush(_coverage_fout);
      ___coverage_array[4347] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4323] == 0) {
        {
        fprintf(_coverage_fout, "4323\n");
        fflush(_coverage_fout);
        ___coverage_array[4323] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___6 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4324] == 0) {
        {
        fprintf(_coverage_fout, "4324\n");
        fflush(_coverage_fout);
        ___coverage_array[4324] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___6 = strlen("days");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4325] == 0) {
        {
        fprintf(_coverage_fout, "4325\n");
        fflush(_coverage_fout);
        ___coverage_array[4325] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___14;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4318] == 0) {
          {
          fprintf(_coverage_fout, "4318\n");
          fflush(_coverage_fout);
          ___coverage_array[4318] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___6 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4316] == 0) {
            {
            fprintf(_coverage_fout, "4316\n");
            fflush(_coverage_fout);
            ___coverage_array[4316] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___14: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("days" + 1)) - (unsigned int )((void const   *)"days") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4312] == 0) {
              {
              fprintf(_coverage_fout, "4312\n");
              fflush(_coverage_fout);
              ___coverage_array[4312] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___55 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4315] == 0) {
              {
              fprintf(_coverage_fout, "4315\n");
              fflush(_coverage_fout);
              ___coverage_array[4315] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___6 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___55 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4314] == 0) {
                {
                fprintf(_coverage_fout, "4314\n");
                fflush(_coverage_fout);
                ___coverage_array[4314] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___55 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4317] == 0) {
            {
            fprintf(_coverage_fout, "4317\n");
            fflush(_coverage_fout);
            ___coverage_array[4317] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___55 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___55) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4319] == 0) {
          {
          fprintf(_coverage_fout, "4319\n");
          fflush(_coverage_fout);
          ___coverage_array[4319] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___50 = __builtin_strcmp((char const   *)member->value.str.val,
                                    "days");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4320] == 0) {
          {
          fprintf(_coverage_fout, "4320\n");
          fflush(_coverage_fout);
          ___coverage_array[4320] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___54 = tmp___50;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4321] == 0) {
          {
          fprintf(_coverage_fout, "4321\n");
          fflush(_coverage_fout);
          ___coverage_array[4321] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___53 = __builtin_strcmp((char const   *)member->value.str.val,
                                    "days");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___54 = tmp___53;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4327] == 0) {
        {
        fprintf(_coverage_fout, "4327\n");
        fflush(_coverage_fout);
        ___coverage_array[4327] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___53 = __builtin_strcmp((char const   *)member->value.str.val, "days");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4328] == 0) {
        {
        fprintf(_coverage_fout, "4328\n");
        fflush(_coverage_fout);
        ___coverage_array[4328] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___54 = tmp___53;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4348] == 0) {
      {
      fprintf(_coverage_fout, "4348\n");
      fflush(_coverage_fout);
      ___coverage_array[4348] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___54 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4329] == 0) {
        {
        fprintf(_coverage_fout, "4329\n");
        fflush(_coverage_fout);
        ___coverage_array[4329] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      value = (obj->diff)->days;
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4330] == 0) {
        {
        fprintf(_coverage_fout, "4330\n");
        fflush(_coverage_fout);
        ___coverage_array[4330] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___56 = zend_get_std_object_handlers();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4350] == 0) {
      {
      fprintf(_coverage_fout, "4350\n");
      fflush(_coverage_fout);
      ___coverage_array[4350] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval = (*(tmp___56->read_property))(object, member, type, key);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4351] == 0) {
      {
      fprintf(_coverage_fout, "4351\n");
      fflush(_coverage_fout);
      ___coverage_array[4351] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )member == (unsigned int )(& tmp_member)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4331] == 0) {
        {
        fprintf(_coverage_fout, "4331\n");
        fflush(_coverage_fout);
        ___coverage_array[4331] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _zval_dtor(member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4332] == 0) {
        {
        fprintf(_coverage_fout, "4332\n");
        fflush(_coverage_fout);
        ___coverage_array[4332] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4352] == 0) {
      {
      fprintf(_coverage_fout, "4352\n");
      fflush(_coverage_fout);
      ___coverage_array[4352] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return (retval);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4363] == 0) {
    {
    fprintf(_coverage_fout, "4363\n");
    fflush(_coverage_fout);
    ___coverage_array[4363] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4353] == 0) {
      {
      fprintf(_coverage_fout, "4353\n");
      fflush(_coverage_fout);
      ___coverage_array[4353] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___57 = _emalloc(sizeof(zval_gc_info ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4354] == 0) {
      {
      fprintf(_coverage_fout, "4354\n");
      fflush(_coverage_fout);
      ___coverage_array[4354] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval = (zval *)tmp___57;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4355] == 0) {
      {
      fprintf(_coverage_fout, "4355\n");
      fflush(_coverage_fout);
      ___coverage_array[4355] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    ((zval_gc_info *)retval)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4364] == 0) {
    {
    fprintf(_coverage_fout, "4364\n");
    fflush(_coverage_fout);
    ___coverage_array[4364] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  *retval = (struct _zval_struct )zval_used_for_init;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4365] == 0) {
    {
    fprintf(_coverage_fout, "4365\n");
    fflush(_coverage_fout);
    ___coverage_array[4365] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zval_set_refcount_p(retval, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4366] == 0) {
    {
    fprintf(_coverage_fout, "4366\n");
    fflush(_coverage_fout);
    ___coverage_array[4366] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z = retval;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4367] == 0) {
    {
    fprintf(_coverage_fout, "4367\n");
    fflush(_coverage_fout);
    ___coverage_array[4367] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z->value.lval = (long )value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4368] == 0) {
    {
    fprintf(_coverage_fout, "4368\n");
    fflush(_coverage_fout);
    ___coverage_array[4368] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z->type = (unsigned char)1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4369] == 0) {
    {
    fprintf(_coverage_fout, "4369\n");
    fflush(_coverage_fout);
    ___coverage_array[4369] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )member == (unsigned int )(& tmp_member)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4356] == 0) {
      {
      fprintf(_coverage_fout, "4356\n");
      fflush(_coverage_fout);
      ___coverage_array[4356] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4357] == 0) {
      {
      fprintf(_coverage_fout, "4357\n");
      fflush(_coverage_fout);
      ___coverage_array[4357] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4370] == 0) {
    {
    fprintf(_coverage_fout, "4370\n");
    fflush(_coverage_fout);
    ___coverage_array[4370] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
void date_interval_write_property(zval *object , zval *member , zval *value ,
                                  zend_literal const   *key ) 
{ php_interval_obj *obj ;
  zval tmp_member ;
  zval tmp_value ;
  zend_object __attribute__((__visibility__("default")))  *tmp ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___3 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;
  size_t __s1_len___0 ;
  size_t __s2_len___0 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  unsigned char const   *__s2___0 ;
  register int __result___1 ;
  int tmp___10 ;
  unsigned char const   *__s1___0 ;
  register int __result___2 ;
  int tmp___11 ;
  int tmp___12 ;
  int tmp___13 ;
  size_t __s1_len___1 ;
  size_t __s2_len___1 ;
  int tmp___14 ;
  int tmp___15 ;
  int tmp___16 ;
  unsigned char const   *__s2___1 ;
  register int __result___3 ;
  int tmp___17 ;
  unsigned char const   *__s1___1 ;
  register int __result___4 ;
  int tmp___18 ;
  int tmp___19 ;
  int tmp___20 ;
  size_t __s1_len___2 ;
  size_t __s2_len___2 ;
  int tmp___21 ;
  int tmp___22 ;
  int tmp___23 ;
  unsigned char const   *__s2___2 ;
  register int __result___5 ;
  int tmp___24 ;
  unsigned char const   *__s1___2 ;
  register int __result___6 ;
  int tmp___25 ;
  int tmp___26 ;
  int tmp___27 ;
  size_t __s1_len___3 ;
  size_t __s2_len___3 ;
  int tmp___28 ;
  int tmp___29 ;
  int tmp___30 ;
  unsigned char const   *__s2___3 ;
  register int __result___7 ;
  int tmp___31 ;
  unsigned char const   *__s1___3 ;
  register int __result___8 ;
  int tmp___32 ;
  int tmp___33 ;
  int tmp___34 ;
  size_t __s1_len___4 ;
  size_t __s2_len___4 ;
  int tmp___35 ;
  int tmp___36 ;
  int tmp___37 ;
  unsigned char const   *__s2___4 ;
  register int __result___9 ;
  int tmp___38 ;
  unsigned char const   *__s1___4 ;
  register int __result___10 ;
  int tmp___39 ;
  int tmp___40 ;
  int tmp___41 ;
  size_t __s1_len___5 ;
  size_t __s2_len___5 ;
  int tmp___42 ;
  int tmp___43 ;
  int tmp___44 ;
  unsigned char const   *__s2___5 ;
  register int __result___11 ;
  int tmp___45 ;
  unsigned char const   *__s1___5 ;
  register int __result___12 ;
  int tmp___46 ;
  int tmp___47 ;
  int tmp___48 ;
  zend_object_handlers __attribute__((__visibility__("default")))  *tmp___49 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4592] == 0) {
    {
    fprintf(_coverage_fout, "4592\n");
    fflush(_coverage_fout);
    ___coverage_array[4592] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((int )member->type != 6) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4373] == 0) {
      {
      fprintf(_coverage_fout, "4373\n");
      fflush(_coverage_fout);
      ___coverage_array[4373] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp_member = *member;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4374] == 0) {
      {
      fprintf(_coverage_fout, "4374\n");
      fflush(_coverage_fout);
      ___coverage_array[4374] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_copy_ctor(& tmp_member);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 )tmp_member.type != 6) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4371] == 0) {
        {
        fprintf(_coverage_fout, "4371\n");
        fflush(_coverage_fout);
        ___coverage_array[4371] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _convert_to_string(& tmp_member);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4372] == 0) {
        {
        fprintf(_coverage_fout, "4372\n");
        fflush(_coverage_fout);
        ___coverage_array[4372] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4376] == 0) {
      {
      fprintf(_coverage_fout, "4376\n");
      fflush(_coverage_fout);
      ___coverage_array[4376] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    member = & tmp_member;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4377] == 0) {
      {
      fprintf(_coverage_fout, "4377\n");
      fflush(_coverage_fout);
      ___coverage_array[4377] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4593] == 0) {
    {
    fprintf(_coverage_fout, "4593\n");
    fflush(_coverage_fout);
    ___coverage_array[4593] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_objects_get_address((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4594] == 0) {
    {
    fprintf(_coverage_fout, "4594\n");
    fflush(_coverage_fout);
    ___coverage_array[4594] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  obj = (php_interval_obj *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4595] == 0) {
    {
    fprintf(_coverage_fout, "4595\n");
    fflush(_coverage_fout);
    ___coverage_array[4595] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4574] == 0) {
      {
      fprintf(_coverage_fout, "4574\n");
      fflush(_coverage_fout);
      ___coverage_array[4574] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4389] == 0) {
        {
        fprintf(_coverage_fout, "4389\n");
        fflush(_coverage_fout);
        ___coverage_array[4389] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4390] == 0) {
        {
        fprintf(_coverage_fout, "4390\n");
        fflush(_coverage_fout);
        ___coverage_array[4390] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len = strlen("y");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4391] == 0) {
        {
        fprintf(_coverage_fout, "4391\n");
        fflush(_coverage_fout);
        ___coverage_array[4391] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___0;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4384] == 0) {
          {
          fprintf(_coverage_fout, "4384\n");
          fflush(_coverage_fout);
          ___coverage_array[4384] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4382] == 0) {
            {
            fprintf(_coverage_fout, "4382\n");
            fflush(_coverage_fout);
            ___coverage_array[4382] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___0: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("y" + 1)) - (unsigned int )((void const   *)"y") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4378] == 0) {
              {
              fprintf(_coverage_fout, "4378\n");
              fflush(_coverage_fout);
              ___coverage_array[4378] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___6 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4381] == 0) {
              {
              fprintf(_coverage_fout, "4381\n");
              fflush(_coverage_fout);
              ___coverage_array[4381] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4379] == 0) {
                {
                fprintf(_coverage_fout, "4379\n");
                fflush(_coverage_fout);
                ___coverage_array[4379] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___6 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4380] == 0) {
                {
                fprintf(_coverage_fout, "4380\n");
                fflush(_coverage_fout);
                ___coverage_array[4380] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___6 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4383] == 0) {
            {
            fprintf(_coverage_fout, "4383\n");
            fflush(_coverage_fout);
            ___coverage_array[4383] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___6 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4392] == 0) {
        {
        fprintf(_coverage_fout, "4392\n");
        fflush(_coverage_fout);
        ___coverage_array[4392] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___6) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4385] == 0) {
          {
          fprintf(_coverage_fout, "4385\n");
          fflush(_coverage_fout);
          ___coverage_array[4385] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = __builtin_strcmp((char const   *)member->value.str.val, "y");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4386] == 0) {
          {
          fprintf(_coverage_fout, "4386\n");
          fflush(_coverage_fout);
          ___coverage_array[4386] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = tmp___1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4387] == 0) {
          {
          fprintf(_coverage_fout, "4387\n");
          fflush(_coverage_fout);
          ___coverage_array[4387] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___4 = __builtin_strcmp((char const   *)member->value.str.val, "y");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4388] == 0) {
          {
          fprintf(_coverage_fout, "4388\n");
          fflush(_coverage_fout);
          ___coverage_array[4388] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___5 = tmp___4;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4393] == 0) {
        {
        fprintf(_coverage_fout, "4393\n");
        fflush(_coverage_fout);
        ___coverage_array[4393] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___4 = __builtin_strcmp((char const   *)member->value.str.val, "y");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4394] == 0) {
        {
        fprintf(_coverage_fout, "4394\n");
        fflush(_coverage_fout);
        ___coverage_array[4394] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___5 = tmp___4;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4575] == 0) {
      {
      fprintf(_coverage_fout, "4575\n");
      fflush(_coverage_fout);
      ___coverage_array[4575] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___5 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4395] == 0) {
          {
          fprintf(_coverage_fout, "4395\n");
          fflush(_coverage_fout);
          ___coverage_array[4395] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4396] == 0) {
          {
          fprintf(_coverage_fout, "4396\n");
          fflush(_coverage_fout);
          ___coverage_array[4396] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4397] == 0) {
          {
          fprintf(_coverage_fout, "4397\n");
          fflush(_coverage_fout);
          ___coverage_array[4397] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4398] == 0) {
          {
          fprintf(_coverage_fout, "4398\n");
          fflush(_coverage_fout);
          ___coverage_array[4398] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4399] == 0) {
          {
          fprintf(_coverage_fout, "4399\n");
          fflush(_coverage_fout);
          ___coverage_array[4399] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4403] == 0) {
        {
        fprintf(_coverage_fout, "4403\n");
        fflush(_coverage_fout);
        ___coverage_array[4403] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->y = (long long )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4404] == 0) {
        {
        fprintf(_coverage_fout, "4404\n");
        fflush(_coverage_fout);
        ___coverage_array[4404] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((unsigned int )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4400] == 0) {
          {
          fprintf(_coverage_fout, "4400\n");
          fflush(_coverage_fout);
          ___coverage_array[4400] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4401] == 0) {
          {
          fprintf(_coverage_fout, "4401\n");
          fflush(_coverage_fout);
          ___coverage_array[4401] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4405] == 0) {
        {
        fprintf(_coverage_fout, "4405\n");
        fflush(_coverage_fout);
        ___coverage_array[4405] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4417] == 0) {
        {
        fprintf(_coverage_fout, "4417\n");
        fflush(_coverage_fout);
        ___coverage_array[4417] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___0 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4418] == 0) {
        {
        fprintf(_coverage_fout, "4418\n");
        fflush(_coverage_fout);
        ___coverage_array[4418] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___0 = strlen("m");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4419] == 0) {
        {
        fprintf(_coverage_fout, "4419\n");
        fflush(_coverage_fout);
        ___coverage_array[4419] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___2;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4412] == 0) {
          {
          fprintf(_coverage_fout, "4412\n");
          fflush(_coverage_fout);
          ___coverage_array[4412] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___0 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4410] == 0) {
            {
            fprintf(_coverage_fout, "4410\n");
            fflush(_coverage_fout);
            ___coverage_array[4410] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___2: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("m" + 1)) - (unsigned int )((void const   *)"m") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4406] == 0) {
              {
              fprintf(_coverage_fout, "4406\n");
              fflush(_coverage_fout);
              ___coverage_array[4406] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___13 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4409] == 0) {
              {
              fprintf(_coverage_fout, "4409\n");
              fflush(_coverage_fout);
              ___coverage_array[4409] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___0 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4407] == 0) {
                {
                fprintf(_coverage_fout, "4407\n");
                fflush(_coverage_fout);
                ___coverage_array[4407] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___13 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4408] == 0) {
                {
                fprintf(_coverage_fout, "4408\n");
                fflush(_coverage_fout);
                ___coverage_array[4408] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___13 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4411] == 0) {
            {
            fprintf(_coverage_fout, "4411\n");
            fflush(_coverage_fout);
            ___coverage_array[4411] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___13 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___13) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4413] == 0) {
          {
          fprintf(_coverage_fout, "4413\n");
          fflush(_coverage_fout);
          ___coverage_array[4413] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = __builtin_strcmp((char const   *)member->value.str.val, "m");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4414] == 0) {
          {
          fprintf(_coverage_fout, "4414\n");
          fflush(_coverage_fout);
          ___coverage_array[4414] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___12 = tmp___8;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4415] == 0) {
          {
          fprintf(_coverage_fout, "4415\n");
          fflush(_coverage_fout);
          ___coverage_array[4415] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___11 = __builtin_strcmp((char const   *)member->value.str.val, "m");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4416] == 0) {
          {
          fprintf(_coverage_fout, "4416\n");
          fflush(_coverage_fout);
          ___coverage_array[4416] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___12 = tmp___11;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4421] == 0) {
        {
        fprintf(_coverage_fout, "4421\n");
        fflush(_coverage_fout);
        ___coverage_array[4421] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___11 = __builtin_strcmp((char const   *)member->value.str.val, "m");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4422] == 0) {
        {
        fprintf(_coverage_fout, "4422\n");
        fflush(_coverage_fout);
        ___coverage_array[4422] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___12 = tmp___11;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___12 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4423] == 0) {
          {
          fprintf(_coverage_fout, "4423\n");
          fflush(_coverage_fout);
          ___coverage_array[4423] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4424] == 0) {
          {
          fprintf(_coverage_fout, "4424\n");
          fflush(_coverage_fout);
          ___coverage_array[4424] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4425] == 0) {
          {
          fprintf(_coverage_fout, "4425\n");
          fflush(_coverage_fout);
          ___coverage_array[4425] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4426] == 0) {
          {
          fprintf(_coverage_fout, "4426\n");
          fflush(_coverage_fout);
          ___coverage_array[4426] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4427] == 0) {
          {
          fprintf(_coverage_fout, "4427\n");
          fflush(_coverage_fout);
          ___coverage_array[4427] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4431] == 0) {
        {
        fprintf(_coverage_fout, "4431\n");
        fflush(_coverage_fout);
        ___coverage_array[4431] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->m = (long long )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4432] == 0) {
        {
        fprintf(_coverage_fout, "4432\n");
        fflush(_coverage_fout);
        ___coverage_array[4432] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((unsigned int )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4428] == 0) {
          {
          fprintf(_coverage_fout, "4428\n");
          fflush(_coverage_fout);
          ___coverage_array[4428] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4429] == 0) {
          {
          fprintf(_coverage_fout, "4429\n");
          fflush(_coverage_fout);
          ___coverage_array[4429] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4433] == 0) {
        {
        fprintf(_coverage_fout, "4433\n");
        fflush(_coverage_fout);
        ___coverage_array[4433] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4578] == 0) {
      {
      fprintf(_coverage_fout, "4578\n");
      fflush(_coverage_fout);
      ___coverage_array[4578] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4445] == 0) {
        {
        fprintf(_coverage_fout, "4445\n");
        fflush(_coverage_fout);
        ___coverage_array[4445] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___1 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4446] == 0) {
        {
        fprintf(_coverage_fout, "4446\n");
        fflush(_coverage_fout);
        ___coverage_array[4446] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___1 = strlen("d");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4447] == 0) {
        {
        fprintf(_coverage_fout, "4447\n");
        fflush(_coverage_fout);
        ___coverage_array[4447] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___4;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4440] == 0) {
          {
          fprintf(_coverage_fout, "4440\n");
          fflush(_coverage_fout);
          ___coverage_array[4440] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___1 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4438] == 0) {
            {
            fprintf(_coverage_fout, "4438\n");
            fflush(_coverage_fout);
            ___coverage_array[4438] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___4: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("d" + 1)) - (unsigned int )((void const   *)"d") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4434] == 0) {
              {
              fprintf(_coverage_fout, "4434\n");
              fflush(_coverage_fout);
              ___coverage_array[4434] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___20 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4437] == 0) {
              {
              fprintf(_coverage_fout, "4437\n");
              fflush(_coverage_fout);
              ___coverage_array[4437] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___1 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___20 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4436] == 0) {
                {
                fprintf(_coverage_fout, "4436\n");
                fflush(_coverage_fout);
                ___coverage_array[4436] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___20 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4439] == 0) {
            {
            fprintf(_coverage_fout, "4439\n");
            fflush(_coverage_fout);
            ___coverage_array[4439] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___20 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4448] == 0) {
        {
        fprintf(_coverage_fout, "4448\n");
        fflush(_coverage_fout);
        ___coverage_array[4448] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___20) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4441] == 0) {
          {
          fprintf(_coverage_fout, "4441\n");
          fflush(_coverage_fout);
          ___coverage_array[4441] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___15 = __builtin_strcmp((char const   *)member->value.str.val, "d");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4442] == 0) {
          {
          fprintf(_coverage_fout, "4442\n");
          fflush(_coverage_fout);
          ___coverage_array[4442] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___19 = tmp___15;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4443] == 0) {
          {
          fprintf(_coverage_fout, "4443\n");
          fflush(_coverage_fout);
          ___coverage_array[4443] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___18 = __builtin_strcmp((char const   *)member->value.str.val, "d");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4444] == 0) {
          {
          fprintf(_coverage_fout, "4444\n");
          fflush(_coverage_fout);
          ___coverage_array[4444] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___19 = tmp___18;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4449] == 0) {
        {
        fprintf(_coverage_fout, "4449\n");
        fflush(_coverage_fout);
        ___coverage_array[4449] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___18 = __builtin_strcmp((char const   *)member->value.str.val, "d");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4450] == 0) {
        {
        fprintf(_coverage_fout, "4450\n");
        fflush(_coverage_fout);
        ___coverage_array[4450] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___19 = tmp___18;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4579] == 0) {
      {
      fprintf(_coverage_fout, "4579\n");
      fflush(_coverage_fout);
      ___coverage_array[4579] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___19 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4458] == 0) {
        {
        fprintf(_coverage_fout, "4458\n");
        fflush(_coverage_fout);
        ___coverage_array[4458] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4451] == 0) {
          {
          fprintf(_coverage_fout, "4451\n");
          fflush(_coverage_fout);
          ___coverage_array[4451] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4452] == 0) {
          {
          fprintf(_coverage_fout, "4452\n");
          fflush(_coverage_fout);
          ___coverage_array[4452] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4453] == 0) {
          {
          fprintf(_coverage_fout, "4453\n");
          fflush(_coverage_fout);
          ___coverage_array[4453] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4454] == 0) {
          {
          fprintf(_coverage_fout, "4454\n");
          fflush(_coverage_fout);
          ___coverage_array[4454] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4455] == 0) {
          {
          fprintf(_coverage_fout, "4455\n");
          fflush(_coverage_fout);
          ___coverage_array[4455] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4459] == 0) {
        {
        fprintf(_coverage_fout, "4459\n");
        fflush(_coverage_fout);
        ___coverage_array[4459] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->d = (long long )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4460] == 0) {
        {
        fprintf(_coverage_fout, "4460\n");
        fflush(_coverage_fout);
        ___coverage_array[4460] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((unsigned int )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4456] == 0) {
          {
          fprintf(_coverage_fout, "4456\n");
          fflush(_coverage_fout);
          ___coverage_array[4456] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4457] == 0) {
          {
          fprintf(_coverage_fout, "4457\n");
          fflush(_coverage_fout);
          ___coverage_array[4457] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4461] == 0) {
        {
        fprintf(_coverage_fout, "4461\n");
        fflush(_coverage_fout);
        ___coverage_array[4461] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4580] == 0) {
      {
      fprintf(_coverage_fout, "4580\n");
      fflush(_coverage_fout);
      ___coverage_array[4580] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4473] == 0) {
        {
        fprintf(_coverage_fout, "4473\n");
        fflush(_coverage_fout);
        ___coverage_array[4473] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___2 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4474] == 0) {
        {
        fprintf(_coverage_fout, "4474\n");
        fflush(_coverage_fout);
        ___coverage_array[4474] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___2 = strlen("h");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4475] == 0) {
        {
        fprintf(_coverage_fout, "4475\n");
        fflush(_coverage_fout);
        ___coverage_array[4475] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___6;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4468] == 0) {
          {
          fprintf(_coverage_fout, "4468\n");
          fflush(_coverage_fout);
          ___coverage_array[4468] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___2 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4466] == 0) {
            {
            fprintf(_coverage_fout, "4466\n");
            fflush(_coverage_fout);
            ___coverage_array[4466] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___6: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("h" + 1)) - (unsigned int )((void const   *)"h") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4462] == 0) {
              {
              fprintf(_coverage_fout, "4462\n");
              fflush(_coverage_fout);
              ___coverage_array[4462] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___27 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4465] == 0) {
              {
              fprintf(_coverage_fout, "4465\n");
              fflush(_coverage_fout);
              ___coverage_array[4465] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___2 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4463] == 0) {
                {
                fprintf(_coverage_fout, "4463\n");
                fflush(_coverage_fout);
                ___coverage_array[4463] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___27 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4464] == 0) {
                {
                fprintf(_coverage_fout, "4464\n");
                fflush(_coverage_fout);
                ___coverage_array[4464] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___27 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4467] == 0) {
            {
            fprintf(_coverage_fout, "4467\n");
            fflush(_coverage_fout);
            ___coverage_array[4467] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___27 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___27) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4469] == 0) {
          {
          fprintf(_coverage_fout, "4469\n");
          fflush(_coverage_fout);
          ___coverage_array[4469] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___22 = __builtin_strcmp((char const   *)member->value.str.val, "h");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4470] == 0) {
          {
          fprintf(_coverage_fout, "4470\n");
          fflush(_coverage_fout);
          ___coverage_array[4470] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___26 = tmp___22;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4471] == 0) {
          {
          fprintf(_coverage_fout, "4471\n");
          fflush(_coverage_fout);
          ___coverage_array[4471] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___25 = __builtin_strcmp((char const   *)member->value.str.val, "h");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4472] == 0) {
          {
          fprintf(_coverage_fout, "4472\n");
          fflush(_coverage_fout);
          ___coverage_array[4472] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___26 = tmp___25;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4477] == 0) {
        {
        fprintf(_coverage_fout, "4477\n");
        fflush(_coverage_fout);
        ___coverage_array[4477] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___25 = __builtin_strcmp((char const   *)member->value.str.val, "h");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___26 = tmp___25;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4581] == 0) {
      {
      fprintf(_coverage_fout, "4581\n");
      fflush(_coverage_fout);
      ___coverage_array[4581] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___26 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 ((int )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4479] == 0) {
          {
          fprintf(_coverage_fout, "4479\n");
          fflush(_coverage_fout);
          ___coverage_array[4479] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4480] == 0) {
          {
          fprintf(_coverage_fout, "4480\n");
          fflush(_coverage_fout);
          ___coverage_array[4480] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4481] == 0) {
          {
          fprintf(_coverage_fout, "4481\n");
          fflush(_coverage_fout);
          ___coverage_array[4481] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4482] == 0) {
          {
          fprintf(_coverage_fout, "4482\n");
          fflush(_coverage_fout);
          ___coverage_array[4482] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4483] == 0) {
          {
          fprintf(_coverage_fout, "4483\n");
          fflush(_coverage_fout);
          ___coverage_array[4483] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4487] == 0) {
        {
        fprintf(_coverage_fout, "4487\n");
        fflush(_coverage_fout);
        ___coverage_array[4487] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->h = (long long )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 ((unsigned int )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4484] == 0) {
          {
          fprintf(_coverage_fout, "4484\n");
          fflush(_coverage_fout);
          ___coverage_array[4484] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4485] == 0) {
          {
          fprintf(_coverage_fout, "4485\n");
          fflush(_coverage_fout);
          ___coverage_array[4485] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4489] == 0) {
        {
        fprintf(_coverage_fout, "4489\n");
        fflush(_coverage_fout);
        ___coverage_array[4489] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4582] == 0) {
      {
      fprintf(_coverage_fout, "4582\n");
      fflush(_coverage_fout);
      ___coverage_array[4582] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4501] == 0) {
        {
        fprintf(_coverage_fout, "4501\n");
        fflush(_coverage_fout);
        ___coverage_array[4501] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___3 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4502] == 0) {
        {
        fprintf(_coverage_fout, "4502\n");
        fflush(_coverage_fout);
        ___coverage_array[4502] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___3 = strlen("i");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4503] == 0) {
        {
        fprintf(_coverage_fout, "4503\n");
        fflush(_coverage_fout);
        ___coverage_array[4503] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___8;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4496] == 0) {
          {
          fprintf(_coverage_fout, "4496\n");
          fflush(_coverage_fout);
          ___coverage_array[4496] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___3 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4494] == 0) {
            {
            fprintf(_coverage_fout, "4494\n");
            fflush(_coverage_fout);
            ___coverage_array[4494] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___8: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("i" + 1)) - (unsigned int )((void const   *)"i") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4490] == 0) {
              {
              fprintf(_coverage_fout, "4490\n");
              fflush(_coverage_fout);
              ___coverage_array[4490] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___34 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4493] == 0) {
              {
              fprintf(_coverage_fout, "4493\n");
              fflush(_coverage_fout);
              ___coverage_array[4493] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___3 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4491] == 0) {
                {
                fprintf(_coverage_fout, "4491\n");
                fflush(_coverage_fout);
                ___coverage_array[4491] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___34 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4492] == 0) {
                {
                fprintf(_coverage_fout, "4492\n");
                fflush(_coverage_fout);
                ___coverage_array[4492] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___34 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4495] == 0) {
            {
            fprintf(_coverage_fout, "4495\n");
            fflush(_coverage_fout);
            ___coverage_array[4495] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___34 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4504] == 0) {
        {
        fprintf(_coverage_fout, "4504\n");
        fflush(_coverage_fout);
        ___coverage_array[4504] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___34) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4497] == 0) {
          {
          fprintf(_coverage_fout, "4497\n");
          fflush(_coverage_fout);
          ___coverage_array[4497] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___29 = __builtin_strcmp((char const   *)member->value.str.val, "i");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4498] == 0) {
          {
          fprintf(_coverage_fout, "4498\n");
          fflush(_coverage_fout);
          ___coverage_array[4498] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___33 = tmp___29;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4499] == 0) {
          {
          fprintf(_coverage_fout, "4499\n");
          fflush(_coverage_fout);
          ___coverage_array[4499] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___32 = __builtin_strcmp((char const   *)member->value.str.val, "i");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4500] == 0) {
          {
          fprintf(_coverage_fout, "4500\n");
          fflush(_coverage_fout);
          ___coverage_array[4500] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___33 = tmp___32;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___32 = __builtin_strcmp((char const   *)member->value.str.val, "i");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___33 = tmp___32;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4583] == 0) {
      {
      fprintf(_coverage_fout, "4583\n");
      fflush(_coverage_fout);
      ___coverage_array[4583] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___33 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4514] == 0) {
        {
        fprintf(_coverage_fout, "4514\n");
        fflush(_coverage_fout);
        ___coverage_array[4514] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4507] == 0) {
          {
          fprintf(_coverage_fout, "4507\n");
          fflush(_coverage_fout);
          ___coverage_array[4507] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4508] == 0) {
          {
          fprintf(_coverage_fout, "4508\n");
          fflush(_coverage_fout);
          ___coverage_array[4508] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4509] == 0) {
          {
          fprintf(_coverage_fout, "4509\n");
          fflush(_coverage_fout);
          ___coverage_array[4509] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4510] == 0) {
          {
          fprintf(_coverage_fout, "4510\n");
          fflush(_coverage_fout);
          ___coverage_array[4510] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4511] == 0) {
          {
          fprintf(_coverage_fout, "4511\n");
          fflush(_coverage_fout);
          ___coverage_array[4511] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4515] == 0) {
        {
        fprintf(_coverage_fout, "4515\n");
        fflush(_coverage_fout);
        ___coverage_array[4515] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->i = (long long )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4516] == 0) {
        {
        fprintf(_coverage_fout, "4516\n");
        fflush(_coverage_fout);
        ___coverage_array[4516] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((unsigned int )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4512] == 0) {
          {
          fprintf(_coverage_fout, "4512\n");
          fflush(_coverage_fout);
          ___coverage_array[4512] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4513] == 0) {
          {
          fprintf(_coverage_fout, "4513\n");
          fflush(_coverage_fout);
          ___coverage_array[4513] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4517] == 0) {
        {
        fprintf(_coverage_fout, "4517\n");
        fflush(_coverage_fout);
        ___coverage_array[4517] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4584] == 0) {
      {
      fprintf(_coverage_fout, "4584\n");
      fflush(_coverage_fout);
      ___coverage_array[4584] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4529] == 0) {
        {
        fprintf(_coverage_fout, "4529\n");
        fflush(_coverage_fout);
        ___coverage_array[4529] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___4 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4530] == 0) {
        {
        fprintf(_coverage_fout, "4530\n");
        fflush(_coverage_fout);
        ___coverage_array[4530] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___4 = strlen("s");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4531] == 0) {
        {
        fprintf(_coverage_fout, "4531\n");
        fflush(_coverage_fout);
        ___coverage_array[4531] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___10;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4524] == 0) {
          {
          fprintf(_coverage_fout, "4524\n");
          fflush(_coverage_fout);
          ___coverage_array[4524] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (__s1_len___4 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4522] == 0) {
            {
            fprintf(_coverage_fout, "4522\n");
            fflush(_coverage_fout);
            ___coverage_array[4522] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___10: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("s" + 1)) - (unsigned int )((void const   *)"s") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4518] == 0) {
              {
              fprintf(_coverage_fout, "4518\n");
              fflush(_coverage_fout);
              ___coverage_array[4518] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___41 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4521] == 0) {
              {
              fprintf(_coverage_fout, "4521\n");
              fflush(_coverage_fout);
              ___coverage_array[4521] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__s2_len___4 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___41 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___41 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4523] == 0) {
            {
            fprintf(_coverage_fout, "4523\n");
            fflush(_coverage_fout);
            ___coverage_array[4523] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___41 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___41) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4525] == 0) {
          {
          fprintf(_coverage_fout, "4525\n");
          fflush(_coverage_fout);
          ___coverage_array[4525] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___36 = __builtin_strcmp((char const   *)member->value.str.val, "s");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4526] == 0) {
          {
          fprintf(_coverage_fout, "4526\n");
          fflush(_coverage_fout);
          ___coverage_array[4526] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___40 = tmp___36;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4527] == 0) {
          {
          fprintf(_coverage_fout, "4527\n");
          fflush(_coverage_fout);
          ___coverage_array[4527] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___39 = __builtin_strcmp((char const   *)member->value.str.val, "s");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4528] == 0) {
          {
          fprintf(_coverage_fout, "4528\n");
          fflush(_coverage_fout);
          ___coverage_array[4528] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___40 = tmp___39;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4533] == 0) {
        {
        fprintf(_coverage_fout, "4533\n");
        fflush(_coverage_fout);
        ___coverage_array[4533] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___39 = __builtin_strcmp((char const   *)member->value.str.val, "s");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4534] == 0) {
        {
        fprintf(_coverage_fout, "4534\n");
        fflush(_coverage_fout);
        ___coverage_array[4534] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___40 = tmp___39;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4585] == 0) {
      {
      fprintf(_coverage_fout, "4585\n");
      fflush(_coverage_fout);
      ___coverage_array[4585] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___40 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4542] == 0) {
        {
        fprintf(_coverage_fout, "4542\n");
        fflush(_coverage_fout);
        ___coverage_array[4542] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4535] == 0) {
          {
          fprintf(_coverage_fout, "4535\n");
          fflush(_coverage_fout);
          ___coverage_array[4535] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4536] == 0) {
          {
          fprintf(_coverage_fout, "4536\n");
          fflush(_coverage_fout);
          ___coverage_array[4536] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4537] == 0) {
          {
          fprintf(_coverage_fout, "4537\n");
          fflush(_coverage_fout);
          ___coverage_array[4537] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4538] == 0) {
          {
          fprintf(_coverage_fout, "4538\n");
          fflush(_coverage_fout);
          ___coverage_array[4538] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4539] == 0) {
          {
          fprintf(_coverage_fout, "4539\n");
          fflush(_coverage_fout);
          ___coverage_array[4539] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4543] == 0) {
        {
        fprintf(_coverage_fout, "4543\n");
        fflush(_coverage_fout);
        ___coverage_array[4543] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->s = (long long )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4544] == 0) {
        {
        fprintf(_coverage_fout, "4544\n");
        fflush(_coverage_fout);
        ___coverage_array[4544] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((unsigned int )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4540] == 0) {
          {
          fprintf(_coverage_fout, "4540\n");
          fflush(_coverage_fout);
          ___coverage_array[4540] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4541] == 0) {
          {
          fprintf(_coverage_fout, "4541\n");
          fflush(_coverage_fout);
          ___coverage_array[4541] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4545] == 0) {
        {
        fprintf(_coverage_fout, "4545\n");
        fflush(_coverage_fout);
        ___coverage_array[4545] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4557] == 0) {
        {
        fprintf(_coverage_fout, "4557\n");
        fflush(_coverage_fout);
        ___coverage_array[4557] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s1_len___5 = strlen((char const   *)member->value.str.val);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4558] == 0) {
        {
        fprintf(_coverage_fout, "4558\n");
        fflush(_coverage_fout);
        ___coverage_array[4558] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __s2_len___5 = strlen("invert");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4559] == 0) {
        {
        fprintf(_coverage_fout, "4559\n");
        fflush(_coverage_fout);
        ___coverage_array[4559] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (! ((unsigned int )((void const   *)(member->value.str.val + 1)) - (unsigned int )((void const   *)member->value.str.val) == 1U)) {
        goto _L___12;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (__s1_len___5 >= 4U) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4550] == 0) {
            {
            fprintf(_coverage_fout, "4550\n");
            fflush(_coverage_fout);
            ___coverage_array[4550] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          _L___12: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("invert" + 1)) - (unsigned int )((void const   *)"invert") == 1U)) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4546] == 0) {
              {
              fprintf(_coverage_fout, "4546\n");
              fflush(_coverage_fout);
              ___coverage_array[4546] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___48 = 1;
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (__s2_len___5 >= 4U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4547] == 0) {
                {
                fprintf(_coverage_fout, "4547\n");
                fflush(_coverage_fout);
                ___coverage_array[4547] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___48 = 1;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4548] == 0) {
                {
                fprintf(_coverage_fout, "4548\n");
                fflush(_coverage_fout);
                ___coverage_array[4548] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___48 = 0;
            }
          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4551] == 0) {
            {
            fprintf(_coverage_fout, "4551\n");
            fflush(_coverage_fout);
            ___coverage_array[4551] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          tmp___48 = 0;
        }
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4560] == 0) {
        {
        fprintf(_coverage_fout, "4560\n");
        fflush(_coverage_fout);
        ___coverage_array[4560] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp___48) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___43 = __builtin_strcmp((char const   *)member->value.str.val,
                                    "invert");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4554] == 0) {
          {
          fprintf(_coverage_fout, "4554\n");
          fflush(_coverage_fout);
          ___coverage_array[4554] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___47 = tmp___43;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4555] == 0) {
          {
          fprintf(_coverage_fout, "4555\n");
          fflush(_coverage_fout);
          ___coverage_array[4555] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___46 = __builtin_strcmp((char const   *)member->value.str.val,
                                    "invert");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4556] == 0) {
          {
          fprintf(_coverage_fout, "4556\n");
          fflush(_coverage_fout);
          ___coverage_array[4556] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___47 = tmp___46;
      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___46 = __builtin_strcmp((char const   *)member->value.str.val,
                                  "invert");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4562] == 0) {
        {
        fprintf(_coverage_fout, "4562\n");
        fflush(_coverage_fout);
        ___coverage_array[4562] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___47 = tmp___46;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp___47 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4570] == 0) {
        {
        fprintf(_coverage_fout, "4570\n");
        fflush(_coverage_fout);
        ___coverage_array[4570] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )value->type != 1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4563] == 0) {
          {
          fprintf(_coverage_fout, "4563\n");
          fflush(_coverage_fout);
          ___coverage_array[4563] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp_value = *value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4564] == 0) {
          {
          fprintf(_coverage_fout, "4564\n");
          fflush(_coverage_fout);
          ___coverage_array[4564] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_copy_ctor(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4565] == 0) {
          {
          fprintf(_coverage_fout, "4565\n");
          fflush(_coverage_fout);
          ___coverage_array[4565] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        convert_to_long(& tmp_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4566] == 0) {
          {
          fprintf(_coverage_fout, "4566\n");
          fflush(_coverage_fout);
          ___coverage_array[4566] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        value = & tmp_value;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4571] == 0) {
        {
        fprintf(_coverage_fout, "4571\n");
        fflush(_coverage_fout);
        ___coverage_array[4571] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      (obj->diff)->invert = (int )value->value.lval;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 )value == (unsigned int )(& tmp_value)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4568] == 0) {
          {
          fprintf(_coverage_fout, "4568\n");
          fflush(_coverage_fout);
          ___coverage_array[4568] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        _zval_dtor(value);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4569] == 0) {
          {
          fprintf(_coverage_fout, "4569\n");
          fflush(_coverage_fout);
          ___coverage_array[4569] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
      break;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4573] == 0) {
        {
        fprintf(_coverage_fout, "4573\n");
        fflush(_coverage_fout);
        ___coverage_array[4573] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4588] == 0) {
      {
      fprintf(_coverage_fout, "4588\n");
      fflush(_coverage_fout);
      ___coverage_array[4588] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___49 = zend_get_std_object_handlers();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4589] == 0) {
      {
      fprintf(_coverage_fout, "4589\n");
      fflush(_coverage_fout);
      ___coverage_array[4589] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    (*(tmp___49->write_property))(object, member, value, key);
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4596] == 0) {
    {
    fprintf(_coverage_fout, "4596\n");
    fflush(_coverage_fout);
    ___coverage_array[4596] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if ((unsigned int )member == (unsigned int )(& tmp_member)) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4590] == 0) {
      {
      fprintf(_coverage_fout, "4590\n");
      fflush(_coverage_fout);
      ___coverage_array[4590] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _zval_dtor(member);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4591] == 0) {
      {
      fprintf(_coverage_fout, "4591\n");
      fflush(_coverage_fout);
      ___coverage_array[4591] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4597] == 0) {
    {
    fprintf(_coverage_fout, "4597\n");
    fflush(_coverage_fout);
    ___coverage_array[4597] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zim_DateInterval___construct(int ht , zval *return_value ,
                                  zval **return_value_ptr , zval *this_ptr ,
                                  int return_value_used ) 
{ char *interval_string ;
  int interval_string_length ;
  php_interval_obj *diobj ;
  timelib_rel_time *reltime ;
  zend_error_handling error_handling ;
  void __attribute__((__visibility__("default")))  *tmp ;
  int tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4606] == 0) {
    {
    fprintf(_coverage_fout, "4606\n");
    fflush(_coverage_fout);
    ___coverage_array[4606] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  interval_string = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4607] == 0) {
    {
    fprintf(_coverage_fout, "4607\n");
    fflush(_coverage_fout);
    ___coverage_array[4607] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_replace_error_handling((enum __anonenum_zend_error_handling_t_47 )2,
                              (zend_class_entry *)((void *)0), & error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4608] == 0) {
    {
    fprintf(_coverage_fout, "4608\n");
    fflush(_coverage_fout);
    ___coverage_array[4608] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_parse_parameters(ht, "s", & interval_string,
                                  & interval_string_length);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4609] == 0) {
    {
    fprintf(_coverage_fout, "4609\n");
    fflush(_coverage_fout);
    ___coverage_array[4609] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___0 = date_interval_initialize(& reltime, interval_string,
                                       interval_string_length);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___0 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 = zend_object_store_get_object((zval const   *)this_ptr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4599] == 0) {
        {
        fprintf(_coverage_fout, "4599\n");
        fflush(_coverage_fout);
        ___coverage_array[4599] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      diobj = (php_interval_obj *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4600] == 0) {
        {
        fprintf(_coverage_fout, "4600\n");
        fflush(_coverage_fout);
        ___coverage_array[4600] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      diobj->diff = reltime;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4601] == 0) {
        {
        fprintf(_coverage_fout, "4601\n");
        fflush(_coverage_fout);
        ___coverage_array[4601] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      diobj->initialized = 1;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4602] == 0) {
        {
        fprintf(_coverage_fout, "4602\n");
        fflush(_coverage_fout);
        ___coverage_array[4602] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      this_ptr->type = (unsigned char)0;
    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4605] == 0) {
      {
      fprintf(_coverage_fout, "4605\n");
      fflush(_coverage_fout);
      ___coverage_array[4605] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4610] == 0) {
    {
    fprintf(_coverage_fout, "4610\n");
    fflush(_coverage_fout);
    ___coverage_array[4610] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_restore_error_handling(& error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
}
}
void zif_date_interval_create_from_date_string(int ht , zval *return_value ,
                                               zval **return_value_ptr ,
                                               zval *this_ptr ,
                                               int return_value_used ) 
{ char *time_str ;
  int time_str_len ;
  timelib_time *time___0 ;
  timelib_error_container *err ;
  php_interval_obj *diobj ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  timelib_tzdb const   *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4621] == 0) {
    {
    fprintf(_coverage_fout, "4621\n");
    fflush(_coverage_fout);
    ___coverage_array[4621] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4622] == 0) {
    {
    fprintf(_coverage_fout, "4622\n");
    fflush(_coverage_fout);
    ___coverage_array[4622] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time_str_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4623] == 0) {
    {
    fprintf(_coverage_fout, "4623\n");
    fflush(_coverage_fout);
    ___coverage_array[4623] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  err = (timelib_error_container *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 = zend_parse_parameters(ht, "s", & time_str, & time_str_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4615] == 0) {
      {
      fprintf(_coverage_fout, "4615\n");
      fflush(_coverage_fout);
      ___coverage_array[4615] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4612] == 0) {
        {
        fprintf(_coverage_fout, "4612\n");
        fflush(_coverage_fout);
        ___coverage_array[4612] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4613] == 0) {
        {
        fprintf(_coverage_fout, "4613\n");
        fflush(_coverage_fout);
        ___coverage_array[4613] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4614] == 0) {
        {
        fprintf(_coverage_fout, "4614\n");
        fflush(_coverage_fout);
        ___coverage_array[4614] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4616] == 0) {
      {
      fprintf(_coverage_fout, "4616\n");
      fflush(_coverage_fout);
      ___coverage_array[4616] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4617] == 0) {
      {
      fprintf(_coverage_fout, "4617\n");
      fflush(_coverage_fout);
      ___coverage_array[4617] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4626] == 0) {
    {
    fprintf(_coverage_fout, "4626\n");
    fflush(_coverage_fout);
    ___coverage_array[4626] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_date_instantiate(date_ce_interval, return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4618] == 0) {
      {
      fprintf(_coverage_fout, "4618\n");
      fflush(_coverage_fout);
      ___coverage_array[4618] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4619] == 0) {
      {
      fprintf(_coverage_fout, "4619\n");
      fflush(_coverage_fout);
      ___coverage_array[4619] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4620] == 0) {
      {
      fprintf(_coverage_fout, "4620\n");
      fflush(_coverage_fout);
      ___coverage_array[4620] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4628] == 0) {
    {
    fprintf(_coverage_fout, "4628\n");
    fflush(_coverage_fout);
    ___coverage_array[4628] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  time___0 = timelib_strtotime(time_str, time_str_len, & err, tmp___1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___2 = zend_object_store_get_object((zval const   *)return_value);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4630] == 0) {
    {
    fprintf(_coverage_fout, "4630\n");
    fflush(_coverage_fout);
    ___coverage_array[4630] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  diobj = (php_interval_obj *)tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4631] == 0) {
    {
    fprintf(_coverage_fout, "4631\n");
    fflush(_coverage_fout);
    ___coverage_array[4631] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  diobj->diff = timelib_rel_time_clone(& time___0->relative);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4632] == 0) {
    {
    fprintf(_coverage_fout, "4632\n");
    fflush(_coverage_fout);
    ___coverage_array[4632] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  diobj->initialized = 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4633] == 0) {
    {
    fprintf(_coverage_fout, "4633\n");
    fflush(_coverage_fout);
    ___coverage_array[4633] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(time___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4634] == 0) {
    {
    fprintf(_coverage_fout, "4634\n");
    fflush(_coverage_fout);
    ___coverage_array[4634] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_error_container_dtor(err);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4635] == 0) {
    {
    fprintf(_coverage_fout, "4635\n");
    fflush(_coverage_fout);
    ___coverage_array[4635] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static char *date_interval_format(char *format , int format_len ,
                                  timelib_rel_time *t ) 
{ smart_str string ;
  int i ;
  int length ;
  int have_format_spec ;
  char buffer[33] ;
  char __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;
  int __attribute__((__visibility__("default")))  tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;
  int __attribute__((__visibility__("default")))  tmp___9 ;
  int __attribute__((__visibility__("default")))  tmp___10 ;
  int __attribute__((__visibility__("default")))  tmp___11 ;
  int __attribute__((__visibility__("default")))  tmp___12 ;
  int __attribute__((__visibility__("default")))  tmp___13 ;
  char const   *tmp___14 ;
  int __attribute__((__visibility__("default")))  tmp___15 ;
  int tmp___16 ;
  int __attribute__((__visibility__("default")))  tmp___17 ;
  int __attribute__((__visibility__("default")))  tmp___18 ;
  register size_t __nl ;
  smart_str *__dest ;
  void *tmp___19 ;
  void __attribute__((__visibility__("default")))  *tmp___20 ;
  void *tmp___21 ;
  void __attribute__((__visibility__("default")))  *tmp___22 ;
  register size_t __nl___0 ;
  void *tmp___23 ;
  void __attribute__((__visibility__("default")))  *tmp___24 ;
  void *tmp___25 ;
  void __attribute__((__visibility__("default")))  *tmp___26 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4731] == 0) {
    {
    fprintf(_coverage_fout, "4731\n");
    fflush(_coverage_fout);
    ___coverage_array[4731] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string.c = (char *)0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4732] == 0) {
    {
    fprintf(_coverage_fout, "4732\n");
    fflush(_coverage_fout);
    ___coverage_array[4732] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string.len = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4733] == 0) {
    {
    fprintf(_coverage_fout, "4733\n");
    fflush(_coverage_fout);
    ___coverage_array[4733] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  string.a = 0U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4734] == 0) {
    {
    fprintf(_coverage_fout, "4734\n");
    fflush(_coverage_fout);
    ___coverage_array[4734] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  have_format_spec = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (! format_len) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4636] == 0) {
      {
      fprintf(_coverage_fout, "4636\n");
      fflush(_coverage_fout);
      ___coverage_array[4636] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = _estrdup("");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4637] == 0) {
      {
      fprintf(_coverage_fout, "4637\n");
      fflush(_coverage_fout);
      ___coverage_array[4637] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return ((char *)tmp);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4638] == 0) {
      {
      fprintf(_coverage_fout, "4638\n");
      fflush(_coverage_fout);
      ___coverage_array[4638] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4736] == 0) {
    {
    fprintf(_coverage_fout, "4736\n");
    fflush(_coverage_fout);
    ___coverage_array[4736] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  i = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4737] == 0) {
    {
    fprintf(_coverage_fout, "4737\n");
    fflush(_coverage_fout);
    ___coverage_array[4737] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4725] == 0) {
      {
      fprintf(_coverage_fout, "4725\n");
      fflush(_coverage_fout);
      ___coverage_array[4725] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (i < format_len) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4639] == 0) {
        {
        fprintf(_coverage_fout, "4639\n");
        fflush(_coverage_fout);
        ___coverage_array[4639] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (have_format_spec) {
      switch ((int )*(format + i)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4648] == 0) {
        {
        fprintf(_coverage_fout, "4648\n");
        fflush(_coverage_fout);
        ___coverage_array[4648] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 89: 
      tmp___0 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->y);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4649] == 0) {
        {
        fprintf(_coverage_fout, "4649\n");
        fflush(_coverage_fout);
        ___coverage_array[4649] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___0;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4650] == 0) {
        {
        fprintf(_coverage_fout, "4650\n");
        fflush(_coverage_fout);
        ___coverage_array[4650] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 121: 
      tmp___1 = ap_php_slprintf(buffer, 32U, "%d", (int )t->y);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4651] == 0) {
        {
        fprintf(_coverage_fout, "4651\n");
        fflush(_coverage_fout);
        ___coverage_array[4651] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___1;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4652] == 0) {
        {
        fprintf(_coverage_fout, "4652\n");
        fflush(_coverage_fout);
        ___coverage_array[4652] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 77: 
      tmp___2 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->m);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4653] == 0) {
        {
        fprintf(_coverage_fout, "4653\n");
        fflush(_coverage_fout);
        ___coverage_array[4653] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___2;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4654] == 0) {
        {
        fprintf(_coverage_fout, "4654\n");
        fflush(_coverage_fout);
        ___coverage_array[4654] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 109: 
      tmp___3 = ap_php_slprintf(buffer, 32U, "%d", (int )t->m);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4655] == 0) {
        {
        fprintf(_coverage_fout, "4655\n");
        fflush(_coverage_fout);
        ___coverage_array[4655] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___3;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4656] == 0) {
        {
        fprintf(_coverage_fout, "4656\n");
        fflush(_coverage_fout);
        ___coverage_array[4656] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 68: 
      tmp___4 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->d);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4657] == 0) {
        {
        fprintf(_coverage_fout, "4657\n");
        fflush(_coverage_fout);
        ___coverage_array[4657] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___4;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4658] == 0) {
        {
        fprintf(_coverage_fout, "4658\n");
        fflush(_coverage_fout);
        ___coverage_array[4658] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 100: 
      tmp___5 = ap_php_slprintf(buffer, 32U, "%d", (int )t->d);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4659] == 0) {
        {
        fprintf(_coverage_fout, "4659\n");
        fflush(_coverage_fout);
        ___coverage_array[4659] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___5;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4660] == 0) {
        {
        fprintf(_coverage_fout, "4660\n");
        fflush(_coverage_fout);
        ___coverage_array[4660] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 72: 
      tmp___6 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->h);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4661] == 0) {
        {
        fprintf(_coverage_fout, "4661\n");
        fflush(_coverage_fout);
        ___coverage_array[4661] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___6;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4662] == 0) {
        {
        fprintf(_coverage_fout, "4662\n");
        fflush(_coverage_fout);
        ___coverage_array[4662] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 104: 
      tmp___7 = ap_php_slprintf(buffer, 32U, "%d", (int )t->h);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4663] == 0) {
        {
        fprintf(_coverage_fout, "4663\n");
        fflush(_coverage_fout);
        ___coverage_array[4663] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___7;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4664] == 0) {
        {
        fprintf(_coverage_fout, "4664\n");
        fflush(_coverage_fout);
        ___coverage_array[4664] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 73: 
      tmp___8 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->i);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4665] == 0) {
        {
        fprintf(_coverage_fout, "4665\n");
        fflush(_coverage_fout);
        ___coverage_array[4665] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___8;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4666] == 0) {
        {
        fprintf(_coverage_fout, "4666\n");
        fflush(_coverage_fout);
        ___coverage_array[4666] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 105: 
      tmp___9 = ap_php_slprintf(buffer, 32U, "%d", (int )t->i);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4667] == 0) {
        {
        fprintf(_coverage_fout, "4667\n");
        fflush(_coverage_fout);
        ___coverage_array[4667] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___9;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4668] == 0) {
        {
        fprintf(_coverage_fout, "4668\n");
        fflush(_coverage_fout);
        ___coverage_array[4668] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 83: 
      tmp___10 = ap_php_slprintf(buffer, 32U, "%02d", (int )t->s);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4669] == 0) {
        {
        fprintf(_coverage_fout, "4669\n");
        fflush(_coverage_fout);
        ___coverage_array[4669] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___10;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4670] == 0) {
        {
        fprintf(_coverage_fout, "4670\n");
        fflush(_coverage_fout);
        ___coverage_array[4670] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 115: 
      tmp___11 = ap_php_slprintf(buffer, 32U, "%d", (int )t->s);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4671] == 0) {
        {
        fprintf(_coverage_fout, "4671\n");
        fflush(_coverage_fout);
        ___coverage_array[4671] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___11;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4672] == 0) {
        {
        fprintf(_coverage_fout, "4672\n");
        fflush(_coverage_fout);
        ___coverage_array[4672] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 97: 
      if ((int )t->days != -99999) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4640] == 0) {
          {
          fprintf(_coverage_fout, "4640\n");
          fflush(_coverage_fout);
          ___coverage_array[4640] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___12 = ap_php_slprintf(buffer, 32U, "%d", (int )t->days);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4641] == 0) {
          {
          fprintf(_coverage_fout, "4641\n");
          fflush(_coverage_fout);
          ___coverage_array[4641] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        length = (int )tmp___12;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4642] == 0) {
          {
          fprintf(_coverage_fout, "4642\n");
          fflush(_coverage_fout);
          ___coverage_array[4642] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___13 = ap_php_slprintf(buffer, 32U, "(unknown)");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4643] == 0) {
          {
          fprintf(_coverage_fout, "4643\n");
          fflush(_coverage_fout);
          ___coverage_array[4643] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        length = (int )tmp___13;
      }
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4673] == 0) {
        {
        fprintf(_coverage_fout, "4673\n");
        fflush(_coverage_fout);
        ___coverage_array[4673] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 114: 
      if (t->invert) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4644] == 0) {
          {
          fprintf(_coverage_fout, "4644\n");
          fflush(_coverage_fout);
          ___coverage_array[4644] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___14 = "-";
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4645] == 0) {
          {
          fprintf(_coverage_fout, "4645\n");
          fflush(_coverage_fout);
          ___coverage_array[4645] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___14 = "";
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4674] == 0) {
        {
        fprintf(_coverage_fout, "4674\n");
        fflush(_coverage_fout);
        ___coverage_array[4674] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___15 = ap_php_slprintf(buffer, 32U, "%s", tmp___14);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4675] == 0) {
        {
        fprintf(_coverage_fout, "4675\n");
        fflush(_coverage_fout);
        ___coverage_array[4675] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___15;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4676] == 0) {
        {
        fprintf(_coverage_fout, "4676\n");
        fflush(_coverage_fout);
        ___coverage_array[4676] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 82: 
      if (t->invert) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4646] == 0) {
          {
          fprintf(_coverage_fout, "4646\n");
          fflush(_coverage_fout);
          ___coverage_array[4646] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___16 = '-';
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4647] == 0) {
          {
          fprintf(_coverage_fout, "4647\n");
          fflush(_coverage_fout);
          ___coverage_array[4647] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___16 = '+';
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4677] == 0) {
        {
        fprintf(_coverage_fout, "4677\n");
        fflush(_coverage_fout);
        ___coverage_array[4677] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___17 = ap_php_slprintf(buffer, 32U, "%c", tmp___16);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4678] == 0) {
        {
        fprintf(_coverage_fout, "4678\n");
        fflush(_coverage_fout);
        ___coverage_array[4678] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___17;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4679] == 0) {
        {
        fprintf(_coverage_fout, "4679\n");
        fflush(_coverage_fout);
        ___coverage_array[4679] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      case 37: 
      tmp___18 = ap_php_slprintf(buffer, 32U, "%%");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4680] == 0) {
        {
        fprintf(_coverage_fout, "4680\n");
        fflush(_coverage_fout);
        ___coverage_array[4680] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = (int )tmp___18;
      break;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4681] == 0) {
        {
        fprintf(_coverage_fout, "4681\n");
        fflush(_coverage_fout);
        ___coverage_array[4681] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      default: 
      buffer[0] = (char )'%';
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4682] == 0) {
        {
        fprintf(_coverage_fout, "4682\n");
        fflush(_coverage_fout);
        ___coverage_array[4682] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      buffer[1] = *(format + i);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4683] == 0) {
        {
        fprintf(_coverage_fout, "4683\n");
        fflush(_coverage_fout);
        ___coverage_array[4683] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      buffer[2] = (char )'\000';
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4684] == 0) {
        {
        fprintf(_coverage_fout, "4684\n");
        fflush(_coverage_fout);
        ___coverage_array[4684] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      length = 2;
      break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4703] == 0) {
        {
        fprintf(_coverage_fout, "4703\n");
        fflush(_coverage_fout);
        ___coverage_array[4703] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4699] == 0) {
          {
          fprintf(_coverage_fout, "4699\n");
          fflush(_coverage_fout);
          ___coverage_array[4699] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __dest = & string;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4700] == 0) {
          {
          fprintf(_coverage_fout, "4700\n");
          fflush(_coverage_fout);
          ___coverage_array[4700] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4698] == 0) {
            {
            fprintf(_coverage_fout, "4698\n");
            fflush(_coverage_fout);
            ___coverage_array[4698] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          if (! __dest->c) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4687] == 0) {
              {
              fprintf(_coverage_fout, "4687\n");
              fflush(_coverage_fout);
              ___coverage_array[4687] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __dest->len = 0U;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4688] == 0) {
              {
              fprintf(_coverage_fout, "4688\n");
              fflush(_coverage_fout);
              ___coverage_array[4688] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __nl = (unsigned int )length;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4689] == 0) {
              {
              fprintf(_coverage_fout, "4689\n");
              fflush(_coverage_fout);
              ___coverage_array[4689] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__nl < 78U) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4685] == 0) {
                {
                fprintf(_coverage_fout, "4685\n");
                fflush(_coverage_fout);
                ___coverage_array[4685] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              __dest->a = 78U;
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4686] == 0) {
                {
                fprintf(_coverage_fout, "4686\n");
                fflush(_coverage_fout);
                ___coverage_array[4686] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              __dest->a = __nl + 128U;
            }
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4690] == 0) {
              {
              fprintf(_coverage_fout, "4690\n");
              fflush(_coverage_fout);
              ___coverage_array[4690] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            tmp___20 = _erealloc((void *)__dest->c, __dest->a + 1U, 0);
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4691] == 0) {
              {
              fprintf(_coverage_fout, "4691\n");
              fflush(_coverage_fout);
              ___coverage_array[4691] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __dest->c = (char *)((void *)tmp___20);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4696] == 0) {
              {
              fprintf(_coverage_fout, "4696\n");
              fflush(_coverage_fout);
              ___coverage_array[4696] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            __nl = __dest->len + (size_t )length;
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4697] == 0) {
              {
              fprintf(_coverage_fout, "4697\n");
              fflush(_coverage_fout);
              ___coverage_array[4697] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (__nl >= __dest->a) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4692] == 0) {
                {
                fprintf(_coverage_fout, "4692\n");
                fflush(_coverage_fout);
                ___coverage_array[4692] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              __dest->a = __nl + 128U;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4693] == 0) {
                {
                fprintf(_coverage_fout, "4693\n");
                fflush(_coverage_fout);
                ___coverage_array[4693] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___22 = _erealloc((void *)__dest->c, __dest->a + 1U, 0);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4694] == 0) {
                {
                fprintf(_coverage_fout, "4694\n");
                fflush(_coverage_fout);
                ___coverage_array[4694] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              __dest->c = (char *)((void *)tmp___22);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4695] == 0) {
                {
                fprintf(_coverage_fout, "4695\n");
                fflush(_coverage_fout);
                ___coverage_array[4695] = 1;
                }
              }
              fclose(_coverage_fout);
              }

            }
          }
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4701] == 0) {
          {
          fprintf(_coverage_fout, "4701\n");
          fflush(_coverage_fout);
          ___coverage_array[4701] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        memcpy((void */* __restrict  */)(__dest->c + __dest->len),
               (void const   */* __restrict  */)(buffer), (unsigned int )length);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4702] == 0) {
          {
          fprintf(_coverage_fout, "4702\n");
          fflush(_coverage_fout);
          ___coverage_array[4702] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __dest->len = __nl;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4704] == 0) {
        {
        fprintf(_coverage_fout, "4704\n");
        fflush(_coverage_fout);
        ___coverage_array[4704] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      have_format_spec = 0;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4724] == 0) {
        {
        fprintf(_coverage_fout, "4724\n");
        fflush(_coverage_fout);
        ___coverage_array[4724] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )*(format + i) == 37) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4705] == 0) {
          {
          fprintf(_coverage_fout, "4705\n");
          fflush(_coverage_fout);
          ___coverage_array[4705] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        have_format_spec = 1;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4723] == 0) {
          {
          fprintf(_coverage_fout, "4723\n");
          fflush(_coverage_fout);
          ___coverage_array[4723] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4720] == 0) {
            {
            fprintf(_coverage_fout, "4720\n");
            fflush(_coverage_fout);
            ___coverage_array[4720] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          while (1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4719] == 0) {
              {
              fprintf(_coverage_fout, "4719\n");
              fflush(_coverage_fout);
              ___coverage_array[4719] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            if (! string.c) {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4708] == 0) {
                {
                fprintf(_coverage_fout, "4708\n");
                fflush(_coverage_fout);
                ___coverage_array[4708] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              string.len = 0U;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4709] == 0) {
                {
                fprintf(_coverage_fout, "4709\n");
                fflush(_coverage_fout);
                ___coverage_array[4709] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              __nl___0 = 1U;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4710] == 0) {
                {
                fprintf(_coverage_fout, "4710\n");
                fflush(_coverage_fout);
                ___coverage_array[4710] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (__nl___0 < 78U) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4706] == 0) {
                  {
                  fprintf(_coverage_fout, "4706\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4706] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                string.a = 78U;
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4707] == 0) {
                  {
                  fprintf(_coverage_fout, "4707\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4707] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                string.a = __nl___0 + 128U;
              }
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4711] == 0) {
                {
                fprintf(_coverage_fout, "4711\n");
                fflush(_coverage_fout);
                ___coverage_array[4711] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              tmp___24 = _erealloc((void *)string.c, string.a + 1U, 0);
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4712] == 0) {
                {
                fprintf(_coverage_fout, "4712\n");
                fflush(_coverage_fout);
                ___coverage_array[4712] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              string.c = (char *)((void *)tmp___24);
            } else {
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4717] == 0) {
                {
                fprintf(_coverage_fout, "4717\n");
                fflush(_coverage_fout);
                ___coverage_array[4717] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              __nl___0 = string.len + 1U;
              {
              _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                     "a");
              if (___coverage_array[4718] == 0) {
                {
                fprintf(_coverage_fout, "4718\n");
                fflush(_coverage_fout);
                ___coverage_array[4718] = 1;
                }
              }
              fclose(_coverage_fout);
              }
              if (__nl___0 >= string.a) {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4713] == 0) {
                  {
                  fprintf(_coverage_fout, "4713\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4713] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                string.a = __nl___0 + 128U;
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___26 = _erealloc((void *)string.c, string.a + 1U, 0);
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4715] == 0) {
                  {
                  fprintf(_coverage_fout, "4715\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4715] = 1;
                  }
                }
                fclose(_coverage_fout);
                }
                string.c = (char *)((void *)tmp___26);
              } else {
                {
                _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                       "a");
                if (___coverage_array[4716] == 0) {
                  {
                  fprintf(_coverage_fout, "4716\n");
                  fflush(_coverage_fout);
                  ___coverage_array[4716] = 1;
                  }
                }
                fclose(_coverage_fout);
                }

              }
            }
            break;
          }
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4721] == 0) {
            {
            fprintf(_coverage_fout, "4721\n");
            fflush(_coverage_fout);
            ___coverage_array[4721] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          string.len = __nl___0;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4722] == 0) {
            {
            fprintf(_coverage_fout, "4722\n");
            fflush(_coverage_fout);
            ___coverage_array[4722] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          *((unsigned char *)string.c + (string.len - 1U)) = (unsigned char )*(format + i);
          break;
        }
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4727] == 0) {
      {
      fprintf(_coverage_fout, "4727\n");
      fflush(_coverage_fout);
      ___coverage_array[4727] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4738] == 0) {
    {
    fprintf(_coverage_fout, "4738\n");
    fflush(_coverage_fout);
    ___coverage_array[4738] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4730] == 0) {
      {
      fprintf(_coverage_fout, "4730\n");
      fflush(_coverage_fout);
      ___coverage_array[4730] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (string.c) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4728] == 0) {
        {
        fprintf(_coverage_fout, "4728\n");
        fflush(_coverage_fout);
        ___coverage_array[4728] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      *(string.c + string.len) = (char )'\000';
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4729] == 0) {
        {
        fprintf(_coverage_fout, "4729\n");
        fflush(_coverage_fout);
        ___coverage_array[4729] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4739] == 0) {
    {
    fprintf(_coverage_fout, "4739\n");
    fflush(_coverage_fout);
    ___coverage_array[4739] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (string.c);
}
}
void zif_date_interval_format(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ zval *object ;
  php_interval_obj *diobj ;
  char *format ;
  int format_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___0 ;
  char const   *__s ;
  char *tmp___1 ;
  zval *__z___1 ;
  size_t tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 = zend_parse_method_parameters(ht, this_ptr, "Os", & object,
                                     date_ce_interval, & format, & format_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4743] == 0) {
      {
      fprintf(_coverage_fout, "4743\n");
      fflush(_coverage_fout);
      ___coverage_array[4743] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4740] == 0) {
        {
        fprintf(_coverage_fout, "4740\n");
        fflush(_coverage_fout);
        ___coverage_array[4740] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4741] == 0) {
        {
        fprintf(_coverage_fout, "4741\n");
        fflush(_coverage_fout);
        ___coverage_array[4741] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4742] == 0) {
        {
        fprintf(_coverage_fout, "4742\n");
        fflush(_coverage_fout);
        ___coverage_array[4742] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4744] == 0) {
      {
      fprintf(_coverage_fout, "4744\n");
      fflush(_coverage_fout);
      ___coverage_array[4744] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4745] == 0) {
      {
      fprintf(_coverage_fout, "4745\n");
      fflush(_coverage_fout);
      ___coverage_array[4745] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___0 = zend_object_store_get_object((zval const   *)object);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4763] == 0) {
    {
    fprintf(_coverage_fout, "4763\n");
    fflush(_coverage_fout);
    ___coverage_array[4763] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  diobj = (php_interval_obj *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4764] == 0) {
    {
    fprintf(_coverage_fout, "4764\n");
    fflush(_coverage_fout);
    ___coverage_array[4764] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (! diobj->initialized) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4749] == 0) {
      {
      fprintf(_coverage_fout, "4749\n");
      fflush(_coverage_fout);
      ___coverage_array[4749] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "The DateInterval object has not been correctly initialized by its constructor");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4750] == 0) {
      {
      fprintf(_coverage_fout, "4750\n");
      fflush(_coverage_fout);
      ___coverage_array[4750] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4746] == 0) {
        {
        fprintf(_coverage_fout, "4746\n");
        fflush(_coverage_fout);
        ___coverage_array[4746] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4747] == 0) {
        {
        fprintf(_coverage_fout, "4747\n");
        fflush(_coverage_fout);
        ___coverage_array[4747] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4748] == 0) {
        {
        fprintf(_coverage_fout, "4748\n");
        fflush(_coverage_fout);
        ___coverage_array[4748] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4752] == 0) {
      {
      fprintf(_coverage_fout, "4752\n");
      fflush(_coverage_fout);
      ___coverage_array[4752] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4765] == 0) {
    {
    fprintf(_coverage_fout, "4765\n");
    fflush(_coverage_fout);
    ___coverage_array[4765] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___1 = date_interval_format(format, format_len, diobj->diff);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4754] == 0) {
      {
      fprintf(_coverage_fout, "4754\n");
      fflush(_coverage_fout);
      ___coverage_array[4754] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4755] == 0) {
      {
      fprintf(_coverage_fout, "4755\n");
      fflush(_coverage_fout);
      ___coverage_array[4755] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4756] == 0) {
      {
      fprintf(_coverage_fout, "4756\n");
      fflush(_coverage_fout);
      ___coverage_array[4756] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4757] == 0) {
      {
      fprintf(_coverage_fout, "4757\n");
      fflush(_coverage_fout);
      ___coverage_array[4757] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.str.len = (int )tmp___2;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4758] == 0) {
      {
      fprintf(_coverage_fout, "4758\n");
      fflush(_coverage_fout);
      ___coverage_array[4758] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4759] == 0) {
      {
      fprintf(_coverage_fout, "4759\n");
      fflush(_coverage_fout);
      ___coverage_array[4759] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4766] == 0) {
    {
    fprintf(_coverage_fout, "4766\n");
    fflush(_coverage_fout);
    ___coverage_array[4766] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int date_period_initialize(timelib_time **st , timelib_time **et ,
                                  timelib_rel_time **d , long *recurrences ,
                                  char *format , int format_length ) 
{ timelib_time *b ;
  timelib_time *e ;
  timelib_rel_time *p ;
  int r ;
  int retval ;
  struct timelib_error_container *errors ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4774] == 0) {
    {
    fprintf(_coverage_fout, "4774\n");
    fflush(_coverage_fout);
    ___coverage_array[4774] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  b = (timelib_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4775] == 0) {
    {
    fprintf(_coverage_fout, "4775\n");
    fflush(_coverage_fout);
    ___coverage_array[4775] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  e = (timelib_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4776] == 0) {
    {
    fprintf(_coverage_fout, "4776\n");
    fflush(_coverage_fout);
    ___coverage_array[4776] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  p = (timelib_rel_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4777] == 0) {
    {
    fprintf(_coverage_fout, "4777\n");
    fflush(_coverage_fout);
    ___coverage_array[4777] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  r = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4778] == 0) {
    {
    fprintf(_coverage_fout, "4778\n");
    fflush(_coverage_fout);
    ___coverage_array[4778] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retval = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4779] == 0) {
    {
    fprintf(_coverage_fout, "4779\n");
    fflush(_coverage_fout);
    ___coverage_array[4779] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_strtointerval(format, format_length, & b, & e, & p, & r, & errors);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4780] == 0) {
    {
    fprintf(_coverage_fout, "4780\n");
    fflush(_coverage_fout);
    ___coverage_array[4780] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (errors->error_count > 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4767] == 0) {
      {
      fprintf(_coverage_fout, "4767\n");
      fflush(_coverage_fout);
      ___coverage_array[4767] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 1L,
                      "Unknown or bad format (%s)", format);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4768] == 0) {
      {
      fprintf(_coverage_fout, "4768\n");
      fflush(_coverage_fout);
      ___coverage_array[4768] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval = -1;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4769] == 0) {
      {
      fprintf(_coverage_fout, "4769\n");
      fflush(_coverage_fout);
      ___coverage_array[4769] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *st = b;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4770] == 0) {
      {
      fprintf(_coverage_fout, "4770\n");
      fflush(_coverage_fout);
      ___coverage_array[4770] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *et = e;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4771] == 0) {
      {
      fprintf(_coverage_fout, "4771\n");
      fflush(_coverage_fout);
      ___coverage_array[4771] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *d = p;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4772] == 0) {
      {
      fprintf(_coverage_fout, "4772\n");
      fflush(_coverage_fout);
      ___coverage_array[4772] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    *recurrences = (long )r;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4773] == 0) {
      {
      fprintf(_coverage_fout, "4773\n");
      fflush(_coverage_fout);
      ___coverage_array[4773] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    retval = 0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4781] == 0) {
    {
    fprintf(_coverage_fout, "4781\n");
    fflush(_coverage_fout);
    ___coverage_array[4781] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_error_container_dtor(errors);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4782] == 0) {
    {
    fprintf(_coverage_fout, "4782\n");
    fflush(_coverage_fout);
    ___coverage_array[4782] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (retval);
}
}
void zim_DatePeriod___construct(int ht , zval *return_value ,
                                zval **return_value_ptr , zval *this_ptr ,
                                int return_value_used ) 
{ php_period_obj *dpobj ;
  php_date_obj *dateobj ;
  php_interval_obj *intobj ;
  zval *start ;
  zval *end ;
  zval *interval ;
  long recurrences ;
  long options ;
  char *isostr ;
  int isostr_len ;
  timelib_time *clone ;
  zend_error_handling error_handling ;
  int __attribute__((__visibility__("default")))  tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  void __attribute__((__visibility__("default")))  *tmp___4 ;
  void *tmp___5 ;
  size_t __len ;
  size_t tmp___6 ;
  char *__retval ;
  void *tmp___7 ;
  void *tmp___8 ;
  char *tmp___9 ;
  char *tmp___10 ;
  void __attribute__((__visibility__("default")))  *tmp___11 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4832] == 0) {
    {
    fprintf(_coverage_fout, "4832\n");
    fflush(_coverage_fout);
    ___coverage_array[4832] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  end = (zval *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4833] == 0) {
    {
    fprintf(_coverage_fout, "4833\n");
    fflush(_coverage_fout);
    ___coverage_array[4833] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  recurrences = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4834] == 0) {
    {
    fprintf(_coverage_fout, "4834\n");
    fflush(_coverage_fout);
    ___coverage_array[4834] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  options = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4835] == 0) {
    {
    fprintf(_coverage_fout, "4835\n");
    fflush(_coverage_fout);
    ___coverage_array[4835] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  isostr = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4836] == 0) {
    {
    fprintf(_coverage_fout, "4836\n");
    fflush(_coverage_fout);
    ___coverage_array[4836] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  isostr_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4837] == 0) {
    {
    fprintf(_coverage_fout, "4837\n");
    fflush(_coverage_fout);
    ___coverage_array[4837] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_replace_error_handling((enum __anonenum_zend_error_handling_t_47 )2,
                              (zend_class_entry *)((void *)0), & error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4838] == 0) {
    {
    fprintf(_coverage_fout, "4838\n");
    fflush(_coverage_fout);
    ___coverage_array[4838] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___1 = zend_parse_parameters_ex(1 << 1, ht, "OOl|l", & start, date_ce_date,
                                     & interval, date_ce_interval,
                                     & recurrences, & options);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4839] == 0) {
    {
    fprintf(_coverage_fout, "4839\n");
    fflush(_coverage_fout);
    ___coverage_array[4839] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4790] == 0) {
      {
      fprintf(_coverage_fout, "4790\n");
      fflush(_coverage_fout);
      ___coverage_array[4790] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = zend_parse_parameters_ex(1 << 1, ht, "OOO|l", & start,
                                       date_ce_date, & interval,
                                       date_ce_interval, & end, date_ce_date,
                                       & options);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4791] == 0) {
      {
      fprintf(_coverage_fout, "4791\n");
      fflush(_coverage_fout);
      ___coverage_array[4791] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4787] == 0) {
        {
        fprintf(_coverage_fout, "4787\n");
        fflush(_coverage_fout);
        ___coverage_array[4787] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = zend_parse_parameters_ex(1 << 1, ht, "s|l", & isostr, & isostr_len,
                                     & options);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4788] == 0) {
        {
        fprintf(_coverage_fout, "4788\n");
        fflush(_coverage_fout);
        ___coverage_array[4788] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4783] == 0) {
          {
          fprintf(_coverage_fout, "4783\n");
          fflush(_coverage_fout);
          ___coverage_array[4783] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "This constructor accepts either (DateTime, DateInterval, int) OR (DateTime, DateInterval, DateTime) OR (string) as arguments.");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4784] == 0) {
          {
          fprintf(_coverage_fout, "4784\n");
          fflush(_coverage_fout);
          ___coverage_array[4784] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        zend_restore_error_handling(& error_handling);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4785] == 0) {
          {
          fprintf(_coverage_fout, "4785\n");
          fflush(_coverage_fout);
          ___coverage_array[4785] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        return;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4786] == 0) {
          {
          fprintf(_coverage_fout, "4786\n");
          fflush(_coverage_fout);
          ___coverage_array[4786] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4789] == 0) {
        {
        fprintf(_coverage_fout, "4789\n");
        fflush(_coverage_fout);
        ___coverage_array[4789] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4792] == 0) {
      {
      fprintf(_coverage_fout, "4792\n");
      fflush(_coverage_fout);
      ___coverage_array[4792] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___2 = zend_object_store_get_object((zval const   *)this_ptr);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4841] == 0) {
    {
    fprintf(_coverage_fout, "4841\n");
    fflush(_coverage_fout);
    ___coverage_array[4841] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dpobj = (php_period_obj *)tmp___2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4842] == 0) {
    {
    fprintf(_coverage_fout, "4842\n");
    fflush(_coverage_fout);
    ___coverage_array[4842] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dpobj->current = (timelib_time *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4843] == 0) {
    {
    fprintf(_coverage_fout, "4843\n");
    fflush(_coverage_fout);
    ___coverage_array[4843] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (isostr_len) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4805] == 0) {
      {
      fprintf(_coverage_fout, "4805\n");
      fflush(_coverage_fout);
      ___coverage_array[4805] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    date_period_initialize(& dpobj->start, & dpobj->end, & dpobj->interval,
                           & recurrences, isostr, isostr_len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4806] == 0) {
      {
      fprintf(_coverage_fout, "4806\n");
      fflush(_coverage_fout);
      ___coverage_array[4806] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )dpobj->start == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4793] == 0) {
        {
        fprintf(_coverage_fout, "4793\n");
        fflush(_coverage_fout);
        ___coverage_array[4793] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "The ISO interval \'%s\' did not contain a start date.",
                        isostr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4794] == 0) {
        {
        fprintf(_coverage_fout, "4794\n");
        fflush(_coverage_fout);
        ___coverage_array[4794] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4807] == 0) {
      {
      fprintf(_coverage_fout, "4807\n");
      fflush(_coverage_fout);
      ___coverage_array[4807] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((unsigned int )dpobj->interval == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4795] == 0) {
        {
        fprintf(_coverage_fout, "4795\n");
        fflush(_coverage_fout);
        ___coverage_array[4795] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 1L,
                        "The ISO interval \'%s\' did not contain an interval.",
                        isostr);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4796] == 0) {
        {
        fprintf(_coverage_fout, "4796\n");
        fflush(_coverage_fout);
        ___coverage_array[4796] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 ((unsigned int )dpobj->end == (unsigned int )((void *)0)) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4799] == 0) {
        {
        fprintf(_coverage_fout, "4799\n");
        fflush(_coverage_fout);
        ___coverage_array[4799] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (recurrences == 0L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4797] == 0) {
          {
          fprintf(_coverage_fout, "4797\n");
          fflush(_coverage_fout);
          ___coverage_array[4797] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "The ISO interval \'%s\' did not contain an end date or a recurrence count.",
                          isostr);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4798] == 0) {
          {
          fprintf(_coverage_fout, "4798\n");
          fflush(_coverage_fout);
          ___coverage_array[4798] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4800] == 0) {
        {
        fprintf(_coverage_fout, "4800\n");
        fflush(_coverage_fout);
        ___coverage_array[4800] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4809] == 0) {
      {
      fprintf(_coverage_fout, "4809\n");
      fflush(_coverage_fout);
      ___coverage_array[4809] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (dpobj->start) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4801] == 0) {
        {
        fprintf(_coverage_fout, "4801\n");
        fflush(_coverage_fout);
        ___coverage_array[4801] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_update_ts(dpobj->start, (timelib_tzinfo *)((void *)0));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4802] == 0) {
        {
        fprintf(_coverage_fout, "4802\n");
        fflush(_coverage_fout);
        ___coverage_array[4802] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (dpobj->end) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4803] == 0) {
        {
        fprintf(_coverage_fout, "4803\n");
        fflush(_coverage_fout);
        ___coverage_array[4803] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      timelib_update_ts(dpobj->end, (timelib_tzinfo *)((void *)0));
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4804] == 0) {
        {
        fprintf(_coverage_fout, "4804\n");
        fflush(_coverage_fout);
        ___coverage_array[4804] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4821] == 0) {
      {
      fprintf(_coverage_fout, "4821\n");
      fflush(_coverage_fout);
      ___coverage_array[4821] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = zend_object_store_get_object((zval const   *)interval);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4822] == 0) {
      {
      fprintf(_coverage_fout, "4822\n");
      fflush(_coverage_fout);
      ___coverage_array[4822] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    intobj = (php_interval_obj *)tmp___3;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4823] == 0) {
      {
      fprintf(_coverage_fout, "4823\n");
      fflush(_coverage_fout);
      ___coverage_array[4823] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = zend_object_store_get_object((zval const   *)start);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4824] == 0) {
      {
      fprintf(_coverage_fout, "4824\n");
      fflush(_coverage_fout);
      ___coverage_array[4824] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    dateobj = (php_date_obj *)tmp___4;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4825] == 0) {
      {
      fprintf(_coverage_fout, "4825\n");
      fflush(_coverage_fout);
      ___coverage_array[4825] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    clone = timelib_time_ctor();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4826] == 0) {
      {
      fprintf(_coverage_fout, "4826\n");
      fflush(_coverage_fout);
      ___coverage_array[4826] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    memcpy((void */* __restrict  */)clone,
           (void const   */* __restrict  */)dateobj->time, sizeof(timelib_time ));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4827] == 0) {
      {
      fprintf(_coverage_fout, "4827\n");
      fflush(_coverage_fout);
      ___coverage_array[4827] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((dateobj->time)->tz_abbr) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4811] == 0) {
        {
        fprintf(_coverage_fout, "4811\n");
        fflush(_coverage_fout);
        ___coverage_array[4811] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___10 = __strdup((char const   *)(dateobj->time)->tz_abbr);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4812] == 0) {
        {
        fprintf(_coverage_fout, "4812\n");
        fflush(_coverage_fout);
        ___coverage_array[4812] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      clone->tz_abbr = tmp___10;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4813] == 0) {
        {
        fprintf(_coverage_fout, "4813\n");
        fflush(_coverage_fout);
        ___coverage_array[4813] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4828] == 0) {
      {
      fprintf(_coverage_fout, "4828\n");
      fflush(_coverage_fout);
      ___coverage_array[4828] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((dateobj->time)->tz_info) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4814] == 0) {
        {
        fprintf(_coverage_fout, "4814\n");
        fflush(_coverage_fout);
        ___coverage_array[4814] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      clone->tz_info = (dateobj->time)->tz_info;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4815] == 0) {
        {
        fprintf(_coverage_fout, "4815\n");
        fflush(_coverage_fout);
        ___coverage_array[4815] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4829] == 0) {
      {
      fprintf(_coverage_fout, "4829\n");
      fflush(_coverage_fout);
      ___coverage_array[4829] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    dpobj->start = clone;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4830] == 0) {
      {
      fprintf(_coverage_fout, "4830\n");
      fflush(_coverage_fout);
      ___coverage_array[4830] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    dpobj->interval = timelib_rel_time_clone(intobj->diff);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (end) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4816] == 0) {
        {
        fprintf(_coverage_fout, "4816\n");
        fflush(_coverage_fout);
        ___coverage_array[4816] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___11 = zend_object_store_get_object((zval const   *)end);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4817] == 0) {
        {
        fprintf(_coverage_fout, "4817\n");
        fflush(_coverage_fout);
        ___coverage_array[4817] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      dateobj = (php_date_obj *)tmp___11;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4818] == 0) {
        {
        fprintf(_coverage_fout, "4818\n");
        fflush(_coverage_fout);
        ___coverage_array[4818] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      clone = timelib_time_clone(dateobj->time);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4819] == 0) {
        {
        fprintf(_coverage_fout, "4819\n");
        fflush(_coverage_fout);
        ___coverage_array[4819] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      dpobj->end = clone;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4820] == 0) {
        {
        fprintf(_coverage_fout, "4820\n");
        fflush(_coverage_fout);
        ___coverage_array[4820] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4844] == 0) {
    {
    fprintf(_coverage_fout, "4844\n");
    fflush(_coverage_fout);
    ___coverage_array[4844] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dpobj->include_start_date = ! (options & 1L);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4845] == 0) {
    {
    fprintf(_coverage_fout, "4845\n");
    fflush(_coverage_fout);
    ___coverage_array[4845] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dpobj->recurrences = (int )(recurrences + (long )dpobj->include_start_date);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4846] == 0) {
    {
    fprintf(_coverage_fout, "4846\n");
    fflush(_coverage_fout);
    ___coverage_array[4846] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  dpobj->initialized = 1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4847] == 0) {
    {
    fprintf(_coverage_fout, "4847\n");
    fflush(_coverage_fout);
    ___coverage_array[4847] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zend_restore_error_handling(& error_handling);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4848] == 0) {
    {
    fprintf(_coverage_fout, "4848\n");
    fflush(_coverage_fout);
    ___coverage_array[4848] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static int check_id_allowed(char *id , long what ) 
{ int tmp ;
  int tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  int tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4904] == 0) {
    {
    fprintf(_coverage_fout, "4904\n");
    fflush(_coverage_fout);
    ___coverage_array[4904] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 1L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 = strncasecmp((char const   *)id, "Africa/", 7U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4852] == 0) {
      {
      fprintf(_coverage_fout, "4852\n");
      fflush(_coverage_fout);
      ___coverage_array[4852] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4849] == 0) {
        {
        fprintf(_coverage_fout, "4849\n");
        fflush(_coverage_fout);
        ___coverage_array[4849] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4850] == 0) {
        {
        fprintf(_coverage_fout, "4850\n");
        fflush(_coverage_fout);
        ___coverage_array[4850] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4853] == 0) {
      {
      fprintf(_coverage_fout, "4853\n");
      fflush(_coverage_fout);
      ___coverage_array[4853] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4905] == 0) {
    {
    fprintf(_coverage_fout, "4905\n");
    fflush(_coverage_fout);
    ___coverage_array[4905] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 2L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4856] == 0) {
      {
      fprintf(_coverage_fout, "4856\n");
      fflush(_coverage_fout);
      ___coverage_array[4856] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = strncasecmp((char const   *)id, "America/", 8U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4857] == 0) {
      {
      fprintf(_coverage_fout, "4857\n");
      fflush(_coverage_fout);
      ___coverage_array[4857] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___0 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4854] == 0) {
        {
        fprintf(_coverage_fout, "4854\n");
        fflush(_coverage_fout);
        ___coverage_array[4854] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4855] == 0) {
        {
        fprintf(_coverage_fout, "4855\n");
        fflush(_coverage_fout);
        ___coverage_array[4855] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4906] == 0) {
    {
    fprintf(_coverage_fout, "4906\n");
    fflush(_coverage_fout);
    ___coverage_array[4906] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 4L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___1 = strncasecmp((char const   *)id, "Antarctica/", 11U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4862] == 0) {
      {
      fprintf(_coverage_fout, "4862\n");
      fflush(_coverage_fout);
      ___coverage_array[4862] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___1 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4859] == 0) {
        {
        fprintf(_coverage_fout, "4859\n");
        fflush(_coverage_fout);
        ___coverage_array[4859] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4860] == 0) {
        {
        fprintf(_coverage_fout, "4860\n");
        fflush(_coverage_fout);
        ___coverage_array[4860] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4863] == 0) {
      {
      fprintf(_coverage_fout, "4863\n");
      fflush(_coverage_fout);
      ___coverage_array[4863] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (what & 8L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___2 = strncasecmp((char const   *)id, "Arctic/", 7U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4867] == 0) {
      {
      fprintf(_coverage_fout, "4867\n");
      fflush(_coverage_fout);
      ___coverage_array[4867] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___2 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4864] == 0) {
        {
        fprintf(_coverage_fout, "4864\n");
        fflush(_coverage_fout);
        ___coverage_array[4864] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4865] == 0) {
        {
        fprintf(_coverage_fout, "4865\n");
        fflush(_coverage_fout);
        ___coverage_array[4865] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4868] == 0) {
      {
      fprintf(_coverage_fout, "4868\n");
      fflush(_coverage_fout);
      ___coverage_array[4868] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4908] == 0) {
    {
    fprintf(_coverage_fout, "4908\n");
    fflush(_coverage_fout);
    ___coverage_array[4908] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 16L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4871] == 0) {
      {
      fprintf(_coverage_fout, "4871\n");
      fflush(_coverage_fout);
      ___coverage_array[4871] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = strncasecmp((char const   *)id, "Asia/", 5U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4872] == 0) {
      {
      fprintf(_coverage_fout, "4872\n");
      fflush(_coverage_fout);
      ___coverage_array[4872] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___3 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4869] == 0) {
        {
        fprintf(_coverage_fout, "4869\n");
        fflush(_coverage_fout);
        ___coverage_array[4869] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4870] == 0) {
        {
        fprintf(_coverage_fout, "4870\n");
        fflush(_coverage_fout);
        ___coverage_array[4870] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4873] == 0) {
      {
      fprintf(_coverage_fout, "4873\n");
      fflush(_coverage_fout);
      ___coverage_array[4873] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4909] == 0) {
    {
    fprintf(_coverage_fout, "4909\n");
    fflush(_coverage_fout);
    ___coverage_array[4909] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 32L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4876] == 0) {
      {
      fprintf(_coverage_fout, "4876\n");
      fflush(_coverage_fout);
      ___coverage_array[4876] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___4 = strncasecmp((char const   *)id, "Atlantic/", 9U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4877] == 0) {
      {
      fprintf(_coverage_fout, "4877\n");
      fflush(_coverage_fout);
      ___coverage_array[4877] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___4 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4874] == 0) {
        {
        fprintf(_coverage_fout, "4874\n");
        fflush(_coverage_fout);
        ___coverage_array[4874] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4875] == 0) {
        {
        fprintf(_coverage_fout, "4875\n");
        fflush(_coverage_fout);
        ___coverage_array[4875] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4878] == 0) {
      {
      fprintf(_coverage_fout, "4878\n");
      fflush(_coverage_fout);
      ___coverage_array[4878] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4910] == 0) {
    {
    fprintf(_coverage_fout, "4910\n");
    fflush(_coverage_fout);
    ___coverage_array[4910] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 64L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4881] == 0) {
      {
      fprintf(_coverage_fout, "4881\n");
      fflush(_coverage_fout);
      ___coverage_array[4881] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = strncasecmp((char const   *)id, "Australia/", 10U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4882] == 0) {
      {
      fprintf(_coverage_fout, "4882\n");
      fflush(_coverage_fout);
      ___coverage_array[4882] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___5 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4879] == 0) {
        {
        fprintf(_coverage_fout, "4879\n");
        fflush(_coverage_fout);
        ___coverage_array[4879] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4880] == 0) {
        {
        fprintf(_coverage_fout, "4880\n");
        fflush(_coverage_fout);
        ___coverage_array[4880] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4883] == 0) {
      {
      fprintf(_coverage_fout, "4883\n");
      fflush(_coverage_fout);
      ___coverage_array[4883] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (what & 128L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___6 = strncasecmp((char const   *)id, "Europe/", 7U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4887] == 0) {
      {
      fprintf(_coverage_fout, "4887\n");
      fflush(_coverage_fout);
      ___coverage_array[4887] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___6 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4884] == 0) {
        {
        fprintf(_coverage_fout, "4884\n");
        fflush(_coverage_fout);
        ___coverage_array[4884] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4885] == 0) {
        {
        fprintf(_coverage_fout, "4885\n");
        fflush(_coverage_fout);
        ___coverage_array[4885] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4888] == 0) {
      {
      fprintf(_coverage_fout, "4888\n");
      fflush(_coverage_fout);
      ___coverage_array[4888] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4912] == 0) {
    {
    fprintf(_coverage_fout, "4912\n");
    fflush(_coverage_fout);
    ___coverage_array[4912] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 256L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4891] == 0) {
      {
      fprintf(_coverage_fout, "4891\n");
      fflush(_coverage_fout);
      ___coverage_array[4891] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = strncasecmp((char const   *)id, "Indian/", 7U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4892] == 0) {
      {
      fprintf(_coverage_fout, "4892\n");
      fflush(_coverage_fout);
      ___coverage_array[4892] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___7 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4889] == 0) {
        {
        fprintf(_coverage_fout, "4889\n");
        fflush(_coverage_fout);
        ___coverage_array[4889] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4890] == 0) {
        {
        fprintf(_coverage_fout, "4890\n");
        fflush(_coverage_fout);
        ___coverage_array[4890] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4913] == 0) {
    {
    fprintf(_coverage_fout, "4913\n");
    fflush(_coverage_fout);
    ___coverage_array[4913] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 512L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___8 = strncasecmp((char const   *)id, "Pacific/", 8U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4897] == 0) {
      {
      fprintf(_coverage_fout, "4897\n");
      fflush(_coverage_fout);
      ___coverage_array[4897] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___8 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4894] == 0) {
        {
        fprintf(_coverage_fout, "4894\n");
        fflush(_coverage_fout);
        ___coverage_array[4894] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      return (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4895] == 0) {
        {
        fprintf(_coverage_fout, "4895\n");
        fflush(_coverage_fout);
        ___coverage_array[4895] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4898] == 0) {
      {
      fprintf(_coverage_fout, "4898\n");
      fflush(_coverage_fout);
      ___coverage_array[4898] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4914] == 0) {
    {
    fprintf(_coverage_fout, "4914\n");
    fflush(_coverage_fout);
    ___coverage_array[4914] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what & 1024L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4901] == 0) {
      {
      fprintf(_coverage_fout, "4901\n");
      fflush(_coverage_fout);
      ___coverage_array[4901] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___9 = strncasecmp((char const   *)id, "UTC", 3U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4902] == 0) {
      {
      fprintf(_coverage_fout, "4902\n");
      fflush(_coverage_fout);
      ___coverage_array[4902] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___9 == 0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4900] == 0) {
        {
        fprintf(_coverage_fout, "4900\n");
        fflush(_coverage_fout);
        ___coverage_array[4900] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4903] == 0) {
      {
      fprintf(_coverage_fout, "4903\n");
      fflush(_coverage_fout);
      ___coverage_array[4903] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4915] == 0) {
    {
    fprintf(_coverage_fout, "4915\n");
    fflush(_coverage_fout);
    ___coverage_array[4915] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return (0);
}
}
void zif_timezone_identifiers_list(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) 
{ timelib_tzdb const   *tzdb ;
  timelib_tzdb_index_entry const   *table ;
  int i ;
  int item_count ;
  long what ;
  char *option ;
  int option_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  timelib_tzdb const   *tmp___0 ;
  int tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4951] == 0) {
    {
    fprintf(_coverage_fout, "4951\n");
    fflush(_coverage_fout);
    ___coverage_array[4951] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  what = 2047L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4952] == 0) {
    {
    fprintf(_coverage_fout, "4952\n");
    fflush(_coverage_fout);
    ___coverage_array[4952] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  option = (char *)((void *)0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4953] == 0) {
    {
    fprintf(_coverage_fout, "4953\n");
    fflush(_coverage_fout);
    ___coverage_array[4953] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  option_len = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4954] == 0) {
    {
    fprintf(_coverage_fout, "4954\n");
    fflush(_coverage_fout);
    ___coverage_array[4954] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "|ls", & what, & option, & option_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4919] == 0) {
      {
      fprintf(_coverage_fout, "4919\n");
      fflush(_coverage_fout);
      ___coverage_array[4919] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4916] == 0) {
        {
        fprintf(_coverage_fout, "4916\n");
        fflush(_coverage_fout);
        ___coverage_array[4916] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4917] == 0) {
        {
        fprintf(_coverage_fout, "4917\n");
        fflush(_coverage_fout);
        ___coverage_array[4917] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4918] == 0) {
        {
        fprintf(_coverage_fout, "4918\n");
        fflush(_coverage_fout);
        ___coverage_array[4918] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4920] == 0) {
      {
      fprintf(_coverage_fout, "4920\n");
      fflush(_coverage_fout);
      ___coverage_array[4920] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4921] == 0) {
      {
      fprintf(_coverage_fout, "4921\n");
      fflush(_coverage_fout);
      ___coverage_array[4921] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4956] == 0) {
    {
    fprintf(_coverage_fout, "4956\n");
    fflush(_coverage_fout);
    ___coverage_array[4956] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (what == 4096L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4929] == 0) {
      {
      fprintf(_coverage_fout, "4929\n");
      fflush(_coverage_fout);
      ___coverage_array[4929] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (option_len != 2) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4925] == 0) {
        {
        fprintf(_coverage_fout, "4925\n");
        fflush(_coverage_fout);
        ___coverage_array[4925] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      php_error_docref0((char const   *)((void *)0), 1 << 3L,
                        "A two-letter ISO 3166-1 compatible country code is expected");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4926] == 0) {
        {
        fprintf(_coverage_fout, "4926\n");
        fflush(_coverage_fout);
        ___coverage_array[4926] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4922] == 0) {
          {
          fprintf(_coverage_fout, "4922\n");
          fflush(_coverage_fout);
          ___coverage_array[4922] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___0 = return_value;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4923] == 0) {
          {
          fprintf(_coverage_fout, "4923\n");
          fflush(_coverage_fout);
          ___coverage_array[4923] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___0->value.lval = 0L;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4924] == 0) {
          {
          fprintf(_coverage_fout, "4924\n");
          fflush(_coverage_fout);
          ___coverage_array[4924] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        __z___0->type = (unsigned char)3;
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4928] == 0) {
        {
        fprintf(_coverage_fout, "4928\n");
        fflush(_coverage_fout);
        ___coverage_array[4928] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4930] == 0) {
      {
      fprintf(_coverage_fout, "4930\n");
      fflush(_coverage_fout);
      ___coverage_array[4930] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4957] == 0) {
    {
    fprintf(_coverage_fout, "4957\n");
    fflush(_coverage_fout);
    ___coverage_array[4957] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4931] == 0) {
      {
      fprintf(_coverage_fout, "4931\n");
      fflush(_coverage_fout);
      ___coverage_array[4931] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzdb = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4932] == 0) {
      {
      fprintf(_coverage_fout, "4932\n");
      fflush(_coverage_fout);
      ___coverage_array[4932] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4933] == 0) {
      {
      fprintf(_coverage_fout, "4933\n");
      fflush(_coverage_fout);
      ___coverage_array[4933] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzdb = tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4958] == 0) {
    {
    fprintf(_coverage_fout, "4958\n");
    fflush(_coverage_fout);
    ___coverage_array[4958] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  item_count = (int )tzdb->index_size;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4959] == 0) {
    {
    fprintf(_coverage_fout, "4959\n");
    fflush(_coverage_fout);
    ___coverage_array[4959] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  table = (timelib_tzdb_index_entry const   *)tzdb->index;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4960] == 0) {
    {
    fprintf(_coverage_fout, "4960\n");
    fflush(_coverage_fout);
    ___coverage_array[4960] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4961] == 0) {
    {
    fprintf(_coverage_fout, "4961\n");
    fflush(_coverage_fout);
    ___coverage_array[4961] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  i = 0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4962] == 0) {
    {
    fprintf(_coverage_fout, "4962\n");
    fflush(_coverage_fout);
    ___coverage_array[4962] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4948] == 0) {
      {
      fprintf(_coverage_fout, "4948\n");
      fflush(_coverage_fout);
      ___coverage_array[4948] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (i < item_count) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4934] == 0) {
        {
        fprintf(_coverage_fout, "4934\n");
        fflush(_coverage_fout);
        ___coverage_array[4934] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4949] == 0) {
      {
      fprintf(_coverage_fout, "4949\n");
      fflush(_coverage_fout);
      ___coverage_array[4949] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (what == 4096L) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4939] == 0) {
        {
        fprintf(_coverage_fout, "4939\n");
        fflush(_coverage_fout);
        ___coverage_array[4939] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int const   )*(tzdb->data + ((table + i)->pos + 5U)) == (int const   )*(option + 0)) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 ((int const   )*(tzdb->data + ((table + i)->pos + 6U)) == (int const   )*(option + 1)) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4935] == 0) {
            {
            fprintf(_coverage_fout, "4935\n");
            fflush(_coverage_fout);
            ___coverage_array[4935] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          add_next_index_string(return_value, (char const   *)(table + i)->id, 1);
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4936] == 0) {
            {
            fprintf(_coverage_fout, "4936\n");
            fflush(_coverage_fout);
            ___coverage_array[4936] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4938] == 0) {
          {
          fprintf(_coverage_fout, "4938\n");
          fflush(_coverage_fout);
          ___coverage_array[4938] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4947] == 0) {
        {
        fprintf(_coverage_fout, "4947\n");
        fflush(_coverage_fout);
        ___coverage_array[4947] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (what == 4095L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4940] == 0) {
          {
          fprintf(_coverage_fout, "4940\n");
          fflush(_coverage_fout);
          ___coverage_array[4940] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        add_next_index_string(return_value, (char const   *)(table + i)->id, 1);
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4945] == 0) {
          {
          fprintf(_coverage_fout, "4945\n");
          fflush(_coverage_fout);
          ___coverage_array[4945] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___1 = check_id_allowed((char *)(table + i)->id, what);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4946] == 0) {
          {
          fprintf(_coverage_fout, "4946\n");
          fflush(_coverage_fout);
          ___coverage_array[4946] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        if (tmp___1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 ((int const   )*(tzdb->data + ((table + i)->pos + 4U)) == 1) {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4941] == 0) {
              {
              fprintf(_coverage_fout, "4941\n");
              fflush(_coverage_fout);
              ___coverage_array[4941] = 1;
              }
            }
            fclose(_coverage_fout);
            }
            add_next_index_string(return_value, (char const   *)(table + i)->id,
                                  1);
          } else {
            {
            _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                   "a");
            if (___coverage_array[4942] == 0) {
              {
              fprintf(_coverage_fout, "4942\n");
              fflush(_coverage_fout);
              ___coverage_array[4942] = 1;
              }
            }
            fclose(_coverage_fout);
            }

          }
        } else {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[4944] == 0) {
            {
            fprintf(_coverage_fout, "4944\n");
            fflush(_coverage_fout);
            ___coverage_array[4944] = 1;
            }
          }
          fclose(_coverage_fout);
          }

        }
      }
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4950] == 0) {
      {
      fprintf(_coverage_fout, "4950\n");
      fflush(_coverage_fout);
      ___coverage_array[4950] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    i ++;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4963] == 0) {
    {
    fprintf(_coverage_fout, "4963\n");
    fflush(_coverage_fout);
    ___coverage_array[4963] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_timezone_version_get(int ht , zval *return_value ,
                              zval **return_value_ptr , zval *this_ptr ,
                              int return_value_used ) 
{ timelib_tzdb const   *tzdb ;
  timelib_tzdb const   *tmp ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4974] == 0) {
    {
    fprintf(_coverage_fout, "4974\n");
    fflush(_coverage_fout);
    ___coverage_array[4974] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4964] == 0) {
      {
      fprintf(_coverage_fout, "4964\n");
      fflush(_coverage_fout);
      ___coverage_array[4964] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzdb = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4965] == 0) {
      {
      fprintf(_coverage_fout, "4965\n");
      fflush(_coverage_fout);
      ___coverage_array[4965] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4966] == 0) {
      {
      fprintf(_coverage_fout, "4966\n");
      fflush(_coverage_fout);
      ___coverage_array[4966] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tzdb = tmp;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4975] == 0) {
    {
    fprintf(_coverage_fout, "4975\n");
    fflush(_coverage_fout);
    ___coverage_array[4975] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4967] == 0) {
      {
      fprintf(_coverage_fout, "4967\n");
      fflush(_coverage_fout);
      ___coverage_array[4967] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)tzdb->version;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4968] == 0) {
      {
      fprintf(_coverage_fout, "4968\n");
      fflush(_coverage_fout);
      ___coverage_array[4968] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4969] == 0) {
      {
      fprintf(_coverage_fout, "4969\n");
      fflush(_coverage_fout);
      ___coverage_array[4969] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4970] == 0) {
      {
      fprintf(_coverage_fout, "4970\n");
      fflush(_coverage_fout);
      ___coverage_array[4970] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.len = (int )tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4971] == 0) {
      {
      fprintf(_coverage_fout, "4971\n");
      fflush(_coverage_fout);
      ___coverage_array[4971] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = _estrndup(__s, (unsigned int )__z->value.str.len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4972] == 0) {
      {
      fprintf(_coverage_fout, "4972\n");
      fflush(_coverage_fout);
      ___coverage_array[4972] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.val = (char *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[4973] == 0) {
      {
      fprintf(_coverage_fout, "4973\n");
      fflush(_coverage_fout);
      ___coverage_array[4973] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[4976] == 0) {
    {
    fprintf(_coverage_fout, "4976\n");
    fflush(_coverage_fout);
    ___coverage_array[4976] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_timezone_abbreviations_list(int ht , zval *return_value ,
                                     zval **return_value_ptr , zval *this_ptr ,
                                     int return_value_used ) 
{ timelib_tz_lookup_table const   *table ;
  timelib_tz_lookup_table const   *entry ;
  zval *element ;
  zval **abbr_array_pp ;
  zval *abbr_array ;
  void __attribute__((__visibility__("default")))  *tmp ;
  size_t tmp___0 ;
  size_t tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  void __attribute__((__visibility__("default")))  *tmp___4 ;
  size_t tmp___5 ;
  size_t tmp___6 ;
  HashTable *tmp___7 ;
  HashTable *tmp___8 ;
  HashTable *tmp___9 ;
  int __attribute__((__visibility__("default")))  tmp___10 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5017] == 0) {
    {
    fprintf(_coverage_fout, "5017\n");
    fflush(_coverage_fout);
    ___coverage_array[5017] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  table = timelib_timezone_abbreviations_list();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5018] == 0) {
    {
    fprintf(_coverage_fout, "5018\n");
    fflush(_coverage_fout);
    ___coverage_array[5018] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5019] == 0) {
    {
    fprintf(_coverage_fout, "5019\n");
    fflush(_coverage_fout);
    ___coverage_array[5019] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  entry = table;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5020] == 0) {
    {
    fprintf(_coverage_fout, "5020\n");
    fflush(_coverage_fout);
    ___coverage_array[5020] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5001] == 0) {
      {
      fprintf(_coverage_fout, "5001\n");
      fflush(_coverage_fout);
      ___coverage_array[5001] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4977] == 0) {
        {
        fprintf(_coverage_fout, "4977\n");
        fflush(_coverage_fout);
        ___coverage_array[4977] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp = _emalloc(sizeof(zval_gc_info ));
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4978] == 0) {
        {
        fprintf(_coverage_fout, "4978\n");
        fflush(_coverage_fout);
        ___coverage_array[4978] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      element = (zval *)tmp;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4979] == 0) {
        {
        fprintf(_coverage_fout, "4979\n");
        fflush(_coverage_fout);
        ___coverage_array[4979] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5002] == 0) {
      {
      fprintf(_coverage_fout, "5002\n");
      fflush(_coverage_fout);
      ___coverage_array[5002] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element->refcount__gc = 1U;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5003] == 0) {
      {
      fprintf(_coverage_fout, "5003\n");
      fflush(_coverage_fout);
      ___coverage_array[5003] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    element->is_ref__gc = (unsigned char)0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5004] == 0) {
      {
      fprintf(_coverage_fout, "5004\n");
      fflush(_coverage_fout);
      ___coverage_array[5004] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _array_init(element, 0U);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5005] == 0) {
      {
      fprintf(_coverage_fout, "5005\n");
      fflush(_coverage_fout);
      ___coverage_array[5005] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = strlen("dst");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5006] == 0) {
      {
      fprintf(_coverage_fout, "5006\n");
      fflush(_coverage_fout);
      ___coverage_array[5006] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_bool_ex(element, "dst", tmp___0 + 1U, (int )entry->type);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5007] == 0) {
      {
      fprintf(_coverage_fout, "5007\n");
      fflush(_coverage_fout);
      ___coverage_array[5007] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = strlen("offset");
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5008] == 0) {
      {
      fprintf(_coverage_fout, "5008\n");
      fflush(_coverage_fout);
      ___coverage_array[5008] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_assoc_long_ex(element, "offset", tmp___1 + 1U, (long )entry->gmtoffset);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5009] == 0) {
      {
      fprintf(_coverage_fout, "5009\n");
      fflush(_coverage_fout);
      ___coverage_array[5009] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (entry->full_tz_name) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4980] == 0) {
        {
        fprintf(_coverage_fout, "4980\n");
        fflush(_coverage_fout);
        ___coverage_array[4980] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___2 = strlen("timezone_id");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4981] == 0) {
        {
        fprintf(_coverage_fout, "4981\n");
        fflush(_coverage_fout);
        ___coverage_array[4981] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_string_ex(element, "timezone_id", tmp___2 + 1U,
                          (char *)entry->full_tz_name, 1);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4982] == 0) {
        {
        fprintf(_coverage_fout, "4982\n");
        fflush(_coverage_fout);
        ___coverage_array[4982] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___3 = strlen("timezone_id");
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4983] == 0) {
        {
        fprintf(_coverage_fout, "4983\n");
        fflush(_coverage_fout);
        ___coverage_array[4983] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_null_ex(element, "timezone_id", tmp___3 + 1U);
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5010] == 0) {
      {
      fprintf(_coverage_fout, "5010\n");
      fflush(_coverage_fout);
      ___coverage_array[5010] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = strlen((char const   *)entry->name);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5011] == 0) {
      {
      fprintf(_coverage_fout, "5011\n");
      fflush(_coverage_fout);
      ___coverage_array[5011] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if ((int )return_value->type == 4) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___9 = return_value->value.ht;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4988] == 0) {
        {
        fprintf(_coverage_fout, "4988\n");
        fflush(_coverage_fout);
        ___coverage_array[4988] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if ((int )return_value->type == 5) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4985] == 0) {
          {
          fprintf(_coverage_fout, "4985\n");
          fflush(_coverage_fout);
          ___coverage_array[4985] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___7 = (*((return_value->value.obj.handlers)->get_properties))(return_value);
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___8 = tmp___7;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4987] == 0) {
          {
          fprintf(_coverage_fout, "4987\n");
          fflush(_coverage_fout);
          ___coverage_array[4987] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___8 = (HashTable *)((void *)0);
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4989] == 0) {
        {
        fprintf(_coverage_fout, "4989\n");
        fflush(_coverage_fout);
        ___coverage_array[4989] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___9 = tmp___8;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5012] == 0) {
      {
      fprintf(_coverage_fout, "5012\n");
      fflush(_coverage_fout);
      ___coverage_array[5012] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___10 = zend_hash_find((HashTable const   *)tmp___9,
                              (char const   *)entry->name, tmp___6 + 1U,
                              (void **)(& abbr_array_pp));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5013] == 0) {
      {
      fprintf(_coverage_fout, "5013\n");
      fflush(_coverage_fout);
      ___coverage_array[5013] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (tmp___10 == (int __attribute__((__visibility__("default")))  )-1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4993] == 0) {
        {
        fprintf(_coverage_fout, "4993\n");
        fflush(_coverage_fout);
        ___coverage_array[4993] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      while (1) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4990] == 0) {
          {
          fprintf(_coverage_fout, "4990\n");
          fflush(_coverage_fout);
          ___coverage_array[4990] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        tmp___4 = _emalloc(sizeof(zval_gc_info ));
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4991] == 0) {
          {
          fprintf(_coverage_fout, "4991\n");
          fflush(_coverage_fout);
          ___coverage_array[4991] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        abbr_array = (zval *)tmp___4;
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[4992] == 0) {
          {
          fprintf(_coverage_fout, "4992\n");
          fflush(_coverage_fout);
          ___coverage_array[4992] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        ((zval_gc_info *)abbr_array)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4994] == 0) {
        {
        fprintf(_coverage_fout, "4994\n");
        fflush(_coverage_fout);
        ___coverage_array[4994] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      abbr_array->refcount__gc = 1U;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4995] == 0) {
        {
        fprintf(_coverage_fout, "4995\n");
        fflush(_coverage_fout);
        ___coverage_array[4995] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      abbr_array->is_ref__gc = (unsigned char)0;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4996] == 0) {
        {
        fprintf(_coverage_fout, "4996\n");
        fflush(_coverage_fout);
        ___coverage_array[4996] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      _array_init(abbr_array, 0U);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___5 = strlen((char const   *)entry->name);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4998] == 0) {
        {
        fprintf(_coverage_fout, "4998\n");
        fflush(_coverage_fout);
        ___coverage_array[4998] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      add_assoc_zval_ex(return_value, (char const   *)entry->name, tmp___5 + 1U,
                        abbr_array);
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[4999] == 0) {
        {
        fprintf(_coverage_fout, "4999\n");
        fflush(_coverage_fout);
        ___coverage_array[4999] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      abbr_array = *abbr_array_pp;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5014] == 0) {
      {
      fprintf(_coverage_fout, "5014\n");
      fflush(_coverage_fout);
      ___coverage_array[5014] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    add_next_index_zval(abbr_array, element);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5015] == 0) {
      {
      fprintf(_coverage_fout, "5015\n");
      fflush(_coverage_fout);
      ___coverage_array[5015] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    entry ++;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5016] == 0) {
      {
      fprintf(_coverage_fout, "5016\n");
      fflush(_coverage_fout);
      ___coverage_array[5016] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (entry->name) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5000] == 0) {
        {
        fprintf(_coverage_fout, "5000\n");
        fflush(_coverage_fout);
        ___coverage_array[5000] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    } else {
      break;
    }
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5021] == 0) {
    {
    fprintf(_coverage_fout, "5021\n");
    fflush(_coverage_fout);
    ___coverage_array[5021] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_default_timezone_set(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) 
{ char *zone ;
  int zone_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  timelib_tzdb const   *tmp___0 ;
  timelib_tzdb const   *tmp___1 ;
  int tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;
  zval *__z___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5044] == 0) {
    {
    fprintf(_coverage_fout, "5044\n");
    fflush(_coverage_fout);
    ___coverage_array[5044] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "s", & zone, & zone_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5025] == 0) {
      {
      fprintf(_coverage_fout, "5025\n");
      fflush(_coverage_fout);
      ___coverage_array[5025] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5022] == 0) {
        {
        fprintf(_coverage_fout, "5022\n");
        fflush(_coverage_fout);
        ___coverage_array[5022] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5023] == 0) {
        {
        fprintf(_coverage_fout, "5023\n");
        fflush(_coverage_fout);
        ___coverage_array[5023] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5024] == 0) {
        {
        fprintf(_coverage_fout, "5024\n");
        fflush(_coverage_fout);
        ___coverage_array[5024] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5026] == 0) {
      {
      fprintf(_coverage_fout, "5026\n");
      fflush(_coverage_fout);
      ___coverage_array[5026] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5027] == 0) {
      {
      fprintf(_coverage_fout, "5027\n");
      fflush(_coverage_fout);
      ___coverage_array[5027] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5046] == 0) {
    {
    fprintf(_coverage_fout, "5046\n");
    fflush(_coverage_fout);
    ___coverage_array[5046] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (php_date_global_timezone_db) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5028] == 0) {
      {
      fprintf(_coverage_fout, "5028\n");
      fflush(_coverage_fout);
      ___coverage_array[5028] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = (timelib_tzdb const   *)php_date_global_timezone_db;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5029] == 0) {
      {
      fprintf(_coverage_fout, "5029\n");
      fflush(_coverage_fout);
      ___coverage_array[5029] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = timelib_builtin_db();
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5030] == 0) {
      {
      fprintf(_coverage_fout, "5030\n");
      fflush(_coverage_fout);
      ___coverage_array[5030] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = tmp___0;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5047] == 0) {
    {
    fprintf(_coverage_fout, "5047\n");
    fflush(_coverage_fout);
    ___coverage_array[5047] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = timelib_timezone_id_is_valid(zone, tmp___1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5048] == 0) {
    {
    fprintf(_coverage_fout, "5048\n");
    fflush(_coverage_fout);
    ___coverage_array[5048] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp___2) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5031] == 0) {
      {
      fprintf(_coverage_fout, "5031\n");
      fflush(_coverage_fout);
      ___coverage_array[5031] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5035] == 0) {
      {
      fprintf(_coverage_fout, "5035\n");
      fflush(_coverage_fout);
      ___coverage_array[5035] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    php_error_docref0((char const   *)((void *)0), 1 << 3L,
                      "Timezone ID \'%s\' is invalid", zone);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5036] == 0) {
      {
      fprintf(_coverage_fout, "5036\n");
      fflush(_coverage_fout);
      ___coverage_array[5036] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5032] == 0) {
        {
        fprintf(_coverage_fout, "5032\n");
        fflush(_coverage_fout);
        ___coverage_array[5032] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5033] == 0) {
        {
        fprintf(_coverage_fout, "5033\n");
        fflush(_coverage_fout);
        ___coverage_array[5033] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5034] == 0) {
        {
        fprintf(_coverage_fout, "5034\n");
        fflush(_coverage_fout);
        ___coverage_array[5034] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___0->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5037] == 0) {
      {
      fprintf(_coverage_fout, "5037\n");
      fflush(_coverage_fout);
      ___coverage_array[5037] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5049] == 0) {
    {
    fprintf(_coverage_fout, "5049\n");
    fflush(_coverage_fout);
    ___coverage_array[5049] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (date_globals.timezone) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5038] == 0) {
      {
      fprintf(_coverage_fout, "5038\n");
      fflush(_coverage_fout);
      ___coverage_array[5038] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    _efree((void *)date_globals.timezone);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5039] == 0) {
      {
      fprintf(_coverage_fout, "5039\n");
      fflush(_coverage_fout);
      ___coverage_array[5039] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    date_globals.timezone = (char *)((void *)0);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5040] == 0) {
      {
      fprintf(_coverage_fout, "5040\n");
      fflush(_coverage_fout);
      ___coverage_array[5040] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5050] == 0) {
    {
    fprintf(_coverage_fout, "5050\n");
    fflush(_coverage_fout);
    ___coverage_array[5050] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___3 = _estrndup((char const   *)zone, (unsigned int )zone_len);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5051] == 0) {
    {
    fprintf(_coverage_fout, "5051\n");
    fflush(_coverage_fout);
    ___coverage_array[5051] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  date_globals.timezone = (char *)tmp___3;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5052] == 0) {
    {
    fprintf(_coverage_fout, "5052\n");
    fflush(_coverage_fout);
    ___coverage_array[5052] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5041] == 0) {
      {
      fprintf(_coverage_fout, "5041\n");
      fflush(_coverage_fout);
      ___coverage_array[5041] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5042] == 0) {
      {
      fprintf(_coverage_fout, "5042\n");
      fflush(_coverage_fout);
      ___coverage_array[5042] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->value.lval = 1L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5043] == 0) {
      {
      fprintf(_coverage_fout, "5043\n");
      fflush(_coverage_fout);
      ___coverage_array[5043] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___1->type = (unsigned char)3;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5053] == 0) {
    {
    fprintf(_coverage_fout, "5053\n");
    fflush(_coverage_fout);
    ___coverage_array[5053] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_default_timezone_get(int ht , zval *return_value ,
                                   zval **return_value_ptr , zval *this_ptr ,
                                   int return_value_used ) 
{ timelib_tzinfo *default_tz ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5061] == 0) {
    {
    fprintf(_coverage_fout, "5061\n");
    fflush(_coverage_fout);
    ___coverage_array[5061] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = get_timezone_info();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5062] == 0) {
    {
    fprintf(_coverage_fout, "5062\n");
    fflush(_coverage_fout);
    ___coverage_array[5062] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default_tz = (timelib_tzinfo *)tmp;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5063] == 0) {
    {
    fprintf(_coverage_fout, "5063\n");
    fflush(_coverage_fout);
    ___coverage_array[5063] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5054] == 0) {
      {
      fprintf(_coverage_fout, "5054\n");
      fflush(_coverage_fout);
      ___coverage_array[5054] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)default_tz->name;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5055] == 0) {
      {
      fprintf(_coverage_fout, "5055\n");
      fflush(_coverage_fout);
      ___coverage_array[5055] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5056] == 0) {
      {
      fprintf(_coverage_fout, "5056\n");
      fflush(_coverage_fout);
      ___coverage_array[5056] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___0 = strlen(__s);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5057] == 0) {
      {
      fprintf(_coverage_fout, "5057\n");
      fflush(_coverage_fout);
      ___coverage_array[5057] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.len = (int )tmp___0;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5058] == 0) {
      {
      fprintf(_coverage_fout, "5058\n");
      fflush(_coverage_fout);
      ___coverage_array[5058] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___1 = _estrndup(__s, (unsigned int )__z->value.str.len);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5059] == 0) {
      {
      fprintf(_coverage_fout, "5059\n");
      fflush(_coverage_fout);
      ___coverage_array[5059] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->value.str.val = (char *)tmp___1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5060] == 0) {
      {
      fprintf(_coverage_fout, "5060\n");
      fflush(_coverage_fout);
      ___coverage_array[5060] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5064] == 0) {
    {
    fprintf(_coverage_fout, "5064\n");
    fflush(_coverage_fout);
    ___coverage_array[5064] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
static void php_do_date_sunrise_sunset(int ht , zval *return_value ,
                                       zval **return_value_ptr ,
                                       zval *this_ptr , int return_value_used ,
                                       int calc_sunset ) 
{ double latitude ;
  double longitude ;
  double zenith ;
  double gmt_offset ;
  double altitude ;
  double h_rise ;
  double h_set ;
  double N ;
  timelib_sll rise ;
  timelib_sll set ;
  timelib_sll transit ;
  long time___0 ;
  long retformat ;
  int rs ;
  timelib_time *t ;
  timelib_tzinfo *tzi ;
  char *retstr ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  double __attribute__((__visibility__("default")))  tmp___0 ;
  double __attribute__((__visibility__("default")))  tmp___1 ;
  double __attribute__((__visibility__("default")))  tmp___2 ;
  double __attribute__((__visibility__("default")))  tmp___3 ;
  zval *__z___0 ;
  zval *__z___1 ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___4 ;
  timelib_sll tmp___5 ;
  zval *__z___2 ;
  zval *__z___3 ;
  double tmp___6 ;
  double tmp___7 ;
  char const   *__s ;
  int __l ;
  zval *__z___4 ;
  char __attribute__((__visibility__("default")))  *tmp___8 ;
  zval *__z___5 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5135] == 0) {
    {
    fprintf(_coverage_fout, "5135\n");
    fflush(_coverage_fout);
    ___coverage_array[5135] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  latitude = 0.0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5136] == 0) {
    {
    fprintf(_coverage_fout, "5136\n");
    fflush(_coverage_fout);
    ___coverage_array[5136] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  longitude = 0.0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5137] == 0) {
    {
    fprintf(_coverage_fout, "5137\n");
    fflush(_coverage_fout);
    ___coverage_array[5137] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  zenith = 0.0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5138] == 0) {
    {
    fprintf(_coverage_fout, "5138\n");
    fflush(_coverage_fout);
    ___coverage_array[5138] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  gmt_offset = (double )0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5139] == 0) {
    {
    fprintf(_coverage_fout, "5139\n");
    fflush(_coverage_fout);
    ___coverage_array[5139] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  retformat = 0L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5140] == 0) {
    {
    fprintf(_coverage_fout, "5140\n");
    fflush(_coverage_fout);
    ___coverage_array[5140] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "l|ldddd", & time___0, & retformat,
                              & latitude, & longitude, & zenith, & gmt_offset);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5141] == 0) {
    {
    fprintf(_coverage_fout, "5141\n");
    fflush(_coverage_fout);
    ___coverage_array[5141] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5068] == 0) {
      {
      fprintf(_coverage_fout, "5068\n");
      fflush(_coverage_fout);
      ___coverage_array[5068] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5065] == 0) {
        {
        fprintf(_coverage_fout, "5065\n");
        fflush(_coverage_fout);
        ___coverage_array[5065] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5066] == 0) {
        {
        fprintf(_coverage_fout, "5066\n");
        fflush(_coverage_fout);
        ___coverage_array[5066] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5067] == 0) {
        {
        fprintf(_coverage_fout, "5067\n");
        fflush(_coverage_fout);
        ___coverage_array[5067] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5069] == 0) {
      {
      fprintf(_coverage_fout, "5069\n");
      fflush(_coverage_fout);
      ___coverage_array[5069] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5070] == 0) {
      {
      fprintf(_coverage_fout, "5070\n");
      fflush(_coverage_fout);
      ___coverage_array[5070] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  switch (ht) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5078] == 0) {
    {
    fprintf(_coverage_fout, "5078\n");
    fflush(_coverage_fout);
    ___coverage_array[5078] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  retformat = 1L;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5079] == 0) {
    {
    fprintf(_coverage_fout, "5079\n");
    fflush(_coverage_fout);
    ___coverage_array[5079] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  tmp___0 = zend_ini_double((char *)"date.default_latitude",
                            sizeof("date.default_latitude"), 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5080] == 0) {
    {
    fprintf(_coverage_fout, "5080\n");
    fflush(_coverage_fout);
    ___coverage_array[5080] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  latitude = (double )tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5081] == 0) {
    {
    fprintf(_coverage_fout, "5081\n");
    fflush(_coverage_fout);
    ___coverage_array[5081] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 3: 
  tmp___1 = zend_ini_double((char *)"date.default_longitude",
                            sizeof("date.default_longitude"), 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5082] == 0) {
    {
    fprintf(_coverage_fout, "5082\n");
    fflush(_coverage_fout);
    ___coverage_array[5082] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  longitude = (double )tmp___1;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5083] == 0) {
    {
    fprintf(_coverage_fout, "5083\n");
    fflush(_coverage_fout);
    ___coverage_array[5083] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 4: 
  if (calc_sunset) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5071] == 0) {
      {
      fprintf(_coverage_fout, "5071\n");
      fflush(_coverage_fout);
      ___coverage_array[5071] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___2 = zend_ini_double((char *)"date.sunset_zenith",
                              sizeof("date.sunset_zenith"), 0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5072] == 0) {
      {
      fprintf(_coverage_fout, "5072\n");
      fflush(_coverage_fout);
      ___coverage_array[5072] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zenith = (double )tmp___2;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5073] == 0) {
      {
      fprintf(_coverage_fout, "5073\n");
      fflush(_coverage_fout);
      ___coverage_array[5073] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___3 = zend_ini_double((char *)"date.sunrise_zenith",
                              sizeof("date.sunrise_zenith"), 0);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5074] == 0) {
      {
      fprintf(_coverage_fout, "5074\n");
      fflush(_coverage_fout);
      ___coverage_array[5074] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    zenith = (double )tmp___3;
  }
  case 5: 
  case 6: 
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5084] == 0) {
    {
    fprintf(_coverage_fout, "5084\n");
    fflush(_coverage_fout);
    ___coverage_array[5084] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  php_error_docref0((char const   *)((void *)0), 1 << 1L, "invalid format");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5085] == 0) {
    {
    fprintf(_coverage_fout, "5085\n");
    fflush(_coverage_fout);
    ___coverage_array[5085] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5075] == 0) {
      {
      fprintf(_coverage_fout, "5075\n");
      fflush(_coverage_fout);
      ___coverage_array[5075] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5076] == 0) {
      {
      fprintf(_coverage_fout, "5076\n");
      fflush(_coverage_fout);
      ___coverage_array[5076] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->value.lval = 0L;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5077] == 0) {
      {
      fprintf(_coverage_fout, "5077\n");
      fflush(_coverage_fout);
      ___coverage_array[5077] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___0->type = (unsigned char)3;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5086] == 0) {
    {
    fprintf(_coverage_fout, "5086\n");
    fflush(_coverage_fout);
    ___coverage_array[5086] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5142] == 0) {
    {
    fprintf(_coverage_fout, "5142\n");
    fflush(_coverage_fout);
    ___coverage_array[5142] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (retformat != 0L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5096] == 0) {
      {
      fprintf(_coverage_fout, "5096\n");
      fflush(_coverage_fout);
      ___coverage_array[5096] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (retformat != 1L) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5094] == 0) {
        {
        fprintf(_coverage_fout, "5094\n");
        fflush(_coverage_fout);
        ___coverage_array[5094] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      if (retformat != 2L) {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[5090] == 0) {
          {
          fprintf(_coverage_fout, "5090\n");
          fflush(_coverage_fout);
          ___coverage_array[5090] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        php_error_docref0((char const   *)((void *)0), 1 << 1L,
                          "Wrong return format given, pick one of SUNFUNCS_RET_TIMESTAMP, SUNFUNCS_RET_STRING or SUNFUNCS_RET_DOUBLE");
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[5091] == 0) {
          {
          fprintf(_coverage_fout, "5091\n");
          fflush(_coverage_fout);
          ___coverage_array[5091] = 1;
          }
        }
        fclose(_coverage_fout);
        }
        while (1) {
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5087] == 0) {
            {
            fprintf(_coverage_fout, "5087\n");
            fflush(_coverage_fout);
            ___coverage_array[5087] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __z___1 = return_value;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5088] == 0) {
            {
            fprintf(_coverage_fout, "5088\n");
            fflush(_coverage_fout);
            ___coverage_array[5088] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __z___1->value.lval = 0L;
          {
          _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                                 "a");
          if (___coverage_array[5089] == 0) {
            {
            fprintf(_coverage_fout, "5089\n");
            fflush(_coverage_fout);
            ___coverage_array[5089] = 1;
            }
          }
          fclose(_coverage_fout);
          }
          __z___1->type = (unsigned char)3;
          break;
        }
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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;
      } else {
        {
        _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                               "a");
        if (___coverage_array[5093] == 0) {
          {
          fprintf(_coverage_fout, "5093\n");
          fflush(_coverage_fout);
          ___coverage_array[5093] = 1;
          }
        }
        fclose(_coverage_fout);
        }

      }
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5095] == 0) {
        {
        fprintf(_coverage_fout, "5095\n");
        fflush(_coverage_fout);
        ___coverage_array[5095] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5097] == 0) {
      {
      fprintf(_coverage_fout, "5097\n");
      fflush(_coverage_fout);
      ___coverage_array[5097] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5143] == 0) {
    {
    fprintf(_coverage_fout, "5143\n");
    fflush(_coverage_fout);
    ___coverage_array[5143] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  altitude = (double )90 - zenith;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5144] == 0) {
    {
    fprintf(_coverage_fout, "5144\n");
    fflush(_coverage_fout);
    ___coverage_array[5144] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___4 = get_timezone_info();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5146] == 0) {
    {
    fprintf(_coverage_fout, "5146\n");
    fflush(_coverage_fout);
    ___coverage_array[5146] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)tmp___4;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5147] == 0) {
    {
    fprintf(_coverage_fout, "5147\n");
    fflush(_coverage_fout);
    ___coverage_array[5147] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t->tz_info = tzi;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5148] == 0) {
    {
    fprintf(_coverage_fout, "5148\n");
    fflush(_coverage_fout);
    ___coverage_array[5148] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t->zone_type = 3U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5149] == 0) {
    {
    fprintf(_coverage_fout, "5149\n");
    fflush(_coverage_fout);
    ___coverage_array[5149] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (ht <= 5) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5098] == 0) {
      {
      fprintf(_coverage_fout, "5098\n");
      fflush(_coverage_fout);
      ___coverage_array[5098] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___5 = timelib_get_current_offset(t);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5099] == 0) {
      {
      fprintf(_coverage_fout, "5099\n");
      fflush(_coverage_fout);
      ___coverage_array[5099] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    gmt_offset = (double )(tmp___5 / 3600LL);
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5100] == 0) {
      {
      fprintf(_coverage_fout, "5100\n");
      fflush(_coverage_fout);
      ___coverage_array[5100] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5150] == 0) {
    {
    fprintf(_coverage_fout, "5150\n");
    fflush(_coverage_fout);
    ___coverage_array[5150] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(t, (long long )time___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5151] == 0) {
    {
    fprintf(_coverage_fout, "5151\n");
    fflush(_coverage_fout);
    ___coverage_array[5151] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  rs = timelib_astro_rise_set_altitude(t, longitude, latitude, altitude, 1,
                                       & h_rise, & h_set, & rise, & set,
                                       & transit);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5152] == 0) {
    {
    fprintf(_coverage_fout, "5152\n");
    fflush(_coverage_fout);
    ___coverage_array[5152] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(t);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5153] == 0) {
    {
    fprintf(_coverage_fout, "5153\n");
    fflush(_coverage_fout);
    ___coverage_array[5153] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (rs != 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5104] == 0) {
      {
      fprintf(_coverage_fout, "5104\n");
      fflush(_coverage_fout);
      ___coverage_array[5104] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5101] == 0) {
        {
        fprintf(_coverage_fout, "5101\n");
        fflush(_coverage_fout);
        ___coverage_array[5101] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2 = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5102] == 0) {
        {
        fprintf(_coverage_fout, "5102\n");
        fflush(_coverage_fout);
        ___coverage_array[5102] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5103] == 0) {
        {
        fprintf(_coverage_fout, "5103\n");
        fflush(_coverage_fout);
        ___coverage_array[5103] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___2->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5105] == 0) {
      {
      fprintf(_coverage_fout, "5105\n");
      fflush(_coverage_fout);
      ___coverage_array[5105] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5106] == 0) {
      {
      fprintf(_coverage_fout, "5106\n");
      fflush(_coverage_fout);
      ___coverage_array[5106] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5154] == 0) {
    {
    fprintf(_coverage_fout, "5154\n");
    fflush(_coverage_fout);
    ___coverage_array[5154] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (retformat == 0L) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5109] == 0) {
      {
      fprintf(_coverage_fout, "5109\n");
      fflush(_coverage_fout);
      ___coverage_array[5109] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5110] == 0) {
      {
      fprintf(_coverage_fout, "5110\n");
      fflush(_coverage_fout);
      ___coverage_array[5110] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (calc_sunset) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5107] == 0) {
        {
        fprintf(_coverage_fout, "5107\n");
        fflush(_coverage_fout);
        ___coverage_array[5107] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___3->value.lval = (long )set;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5108] == 0) {
        {
        fprintf(_coverage_fout, "5108\n");
        fflush(_coverage_fout);
        ___coverage_array[5108] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z___3->value.lval = (long )rise;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5111] == 0) {
      {
      fprintf(_coverage_fout, "5111\n");
      fflush(_coverage_fout);
      ___coverage_array[5111] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___3->type = (unsigned char)1;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5112] == 0) {
      {
      fprintf(_coverage_fout, "5112\n");
      fflush(_coverage_fout);
      ___coverage_array[5112] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5113] == 0) {
      {
      fprintf(_coverage_fout, "5113\n");
      fflush(_coverage_fout);
      ___coverage_array[5113] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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 (calc_sunset) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5114] == 0) {
      {
      fprintf(_coverage_fout, "5114\n");
      fflush(_coverage_fout);
      ___coverage_array[5114] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___6 = h_set;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___6 = h_rise;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5156] == 0) {
    {
    fprintf(_coverage_fout, "5156\n");
    fflush(_coverage_fout);
    ___coverage_array[5156] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  N = tmp___6 + gmt_offset;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5157] == 0) {
    {
    fprintf(_coverage_fout, "5157\n");
    fflush(_coverage_fout);
    ___coverage_array[5157] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (N > (double )24) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5116] == 0) {
      {
      fprintf(_coverage_fout, "5116\n");
      fflush(_coverage_fout);
      ___coverage_array[5116] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    tmp___7 = floor(N / (double )24);
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5117] == 0) {
      {
      fprintf(_coverage_fout, "5117\n");
      fflush(_coverage_fout);
      ___coverage_array[5117] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    N -= tmp___7 * (double )24;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5121] == 0) {
      {
      fprintf(_coverage_fout, "5121\n");
      fflush(_coverage_fout);
      ___coverage_array[5121] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    if (N < (double )0) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5118] == 0) {
        {
        fprintf(_coverage_fout, "5118\n");
        fflush(_coverage_fout);
        ___coverage_array[5118] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      tmp___7 = floor(N / (double )24);
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5119] == 0) {
        {
        fprintf(_coverage_fout, "5119\n");
        fflush(_coverage_fout);
        ___coverage_array[5119] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      N -= tmp___7 * (double )24;
    } else {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5120] == 0) {
        {
        fprintf(_coverage_fout, "5120\n");
        fflush(_coverage_fout);
        ___coverage_array[5120] = 1;
        }
      }
      fclose(_coverage_fout);
      }

    }
  }
  switch ((int )retformat) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5128] == 0) {
    {
    fprintf(_coverage_fout, "5128\n");
    fflush(_coverage_fout);
    ___coverage_array[5128] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  spprintf(& retstr, 0U, "%02d:%02d", (int )N,
           (int )((double )60 * (N - (double )((int )N))));
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5129] == 0) {
    {
    fprintf(_coverage_fout, "5129\n");
    fflush(_coverage_fout);
    ___coverage_array[5129] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  while (1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5122] == 0) {
      {
      fprintf(_coverage_fout, "5122\n");
      fflush(_coverage_fout);
      ___coverage_array[5122] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __s = (char const   *)retstr;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5123] == 0) {
      {
      fprintf(_coverage_fout, "5123\n");
      fflush(_coverage_fout);
      ___coverage_array[5123] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __l = 5;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5124] == 0) {
      {
      fprintf(_coverage_fout, "5124\n");
      fflush(_coverage_fout);
      ___coverage_array[5124] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4 = return_value;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5125] == 0) {
      {
      fprintf(_coverage_fout, "5125\n");
      fflush(_coverage_fout);
      ___coverage_array[5125] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4->value.str.len = __l;
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5126] == 0) {
      {
      fprintf(_coverage_fout, "5126\n");
      fflush(_coverage_fout);
      ___coverage_array[5126] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5127] == 0) {
      {
      fprintf(_coverage_fout, "5127\n");
      fflush(_coverage_fout);
      ___coverage_array[5127] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    __z___4->type = (unsigned char)6;
    break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5130] == 0) {
    {
    fprintf(_coverage_fout, "5130\n");
    fflush(_coverage_fout);
    ___coverage_array[5130] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5131] == 0) {
    {
    fprintf(_coverage_fout, "5131\n");
    fflush(_coverage_fout);
    ___coverage_array[5131] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 2: 
  __z___5 = return_value;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5132] == 0) {
    {
    fprintf(_coverage_fout, "5132\n");
    fflush(_coverage_fout);
    ___coverage_array[5132] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___5->value.dval = N;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5133] == 0) {
    {
    fprintf(_coverage_fout, "5133\n");
    fflush(_coverage_fout);
    ___coverage_array[5133] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  __z___5->type = (unsigned char)2;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5134] == 0) {
    {
    fprintf(_coverage_fout, "5134\n");
    fflush(_coverage_fout);
    ___coverage_array[5134] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
  break;
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5158] == 0) {
    {
    fprintf(_coverage_fout, "5158\n");
    fflush(_coverage_fout);
    ___coverage_array[5158] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_sunrise(int ht , zval *return_value , zval **return_value_ptr ,
                      zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5159] == 0) {
    {
    fprintf(_coverage_fout, "5159\n");
    fflush(_coverage_fout);
    ___coverage_array[5159] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_do_date_sunrise_sunset(ht, return_value, return_value_ptr, this_ptr,
                             return_value_used, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5160] == 0) {
    {
    fprintf(_coverage_fout, "5160\n");
    fflush(_coverage_fout);
    ___coverage_array[5160] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_sunset(int ht , zval *return_value , zval **return_value_ptr ,
                     zval *this_ptr , int return_value_used ) 
{ 

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5161] == 0) {
    {
    fprintf(_coverage_fout, "5161\n");
    fflush(_coverage_fout);
    ___coverage_array[5161] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  php_do_date_sunrise_sunset(ht, return_value, return_value_ptr, this_ptr,
                             return_value_used, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5162] == 0) {
    {
    fprintf(_coverage_fout, "5162\n");
    fflush(_coverage_fout);
    ___coverage_array[5162] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
void zif_date_sun_info(int ht , zval *return_value , zval **return_value_ptr ,
                       zval *this_ptr , int return_value_used ) 
{ long time___0 ;
  double latitude ;
  double longitude ;
  timelib_time *t ;
  timelib_time *t2 ;
  timelib_tzinfo *tzi ;
  int rs ;
  timelib_sll rise ;
  timelib_sll set ;
  timelib_sll transit ;
  int dummy ;
  double ddummy ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  timelib_tzinfo __attribute__((__visibility__("default")))  *tmp___0 ;
  size_t tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  size_t tmp___4 ;
  long tmp___5 ;
  size_t tmp___6 ;
  long tmp___7 ;
  size_t tmp___8 ;
  long tmp___9 ;
  size_t tmp___10 ;
  size_t tmp___11 ;
  size_t tmp___12 ;
  size_t tmp___13 ;
  size_t tmp___14 ;
  long tmp___15 ;
  size_t tmp___16 ;
  long tmp___17 ;
  size_t tmp___18 ;
  size_t tmp___19 ;
  size_t tmp___20 ;
  size_t tmp___21 ;
  size_t tmp___22 ;
  long tmp___23 ;
  size_t tmp___24 ;
  long tmp___25 ;
  size_t tmp___26 ;
  size_t tmp___27 ;
  size_t tmp___28 ;
  size_t tmp___29 ;
  size_t tmp___30 ;
  long tmp___31 ;
  size_t tmp___32 ;
  long tmp___33 ;
  size_t tmp___34 ;

  {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5233] == 0) {
    {
    fprintf(_coverage_fout, "5233\n");
    fflush(_coverage_fout);
    ___coverage_array[5233] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp = zend_parse_parameters(ht, "ldd", & time___0, & latitude, & longitude);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5234] == 0) {
    {
    fprintf(_coverage_fout, "5234\n");
    fflush(_coverage_fout);
    ___coverage_array[5234] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5166] == 0) {
      {
      fprintf(_coverage_fout, "5166\n");
      fflush(_coverage_fout);
      ___coverage_array[5166] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    while (1) {
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5163] == 0) {
        {
        fprintf(_coverage_fout, "5163\n");
        fflush(_coverage_fout);
        ___coverage_array[5163] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z = return_value;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5164] == 0) {
        {
        fprintf(_coverage_fout, "5164\n");
        fflush(_coverage_fout);
        ___coverage_array[5164] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->value.lval = 0L;
      {
      _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                             "a");
      if (___coverage_array[5165] == 0) {
        {
        fprintf(_coverage_fout, "5165\n");
        fflush(_coverage_fout);
        ___coverage_array[5165] = 1;
        }
      }
      fclose(_coverage_fout);
      }
      __z->type = (unsigned char)3;
      break;
    }
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5167] == 0) {
      {
      fprintf(_coverage_fout, "5167\n");
      fflush(_coverage_fout);
      ___coverage_array[5167] = 1;
      }
    }
    fclose(_coverage_fout);
    }
    return;
  } else {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                           "a");
    if (___coverage_array[5168] == 0) {
      {
      fprintf(_coverage_fout, "5168\n");
      fflush(_coverage_fout);
      ___coverage_array[5168] = 1;
      }
    }
    fclose(_coverage_fout);
    }

  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5235] == 0) {
    {
    fprintf(_coverage_fout, "5235\n");
    fflush(_coverage_fout);
    ___coverage_array[5235] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5236] == 0) {
    {
    fprintf(_coverage_fout, "5236\n");
    fflush(_coverage_fout);
    ___coverage_array[5236] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___0 = get_timezone_info();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5237] == 0) {
    {
    fprintf(_coverage_fout, "5237\n");
    fflush(_coverage_fout);
    ___coverage_array[5237] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tzi = (timelib_tzinfo *)tmp___0;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5238] == 0) {
    {
    fprintf(_coverage_fout, "5238\n");
    fflush(_coverage_fout);
    ___coverage_array[5238] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t->tz_info = tzi;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5239] == 0) {
    {
    fprintf(_coverage_fout, "5239\n");
    fflush(_coverage_fout);
    ___coverage_array[5239] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t->zone_type = 3U;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5240] == 0) {
    {
    fprintf(_coverage_fout, "5240\n");
    fflush(_coverage_fout);
    ___coverage_array[5240] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_unixtime2local(t, (long long )time___0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5241] == 0) {
    {
    fprintf(_coverage_fout, "5241\n");
    fflush(_coverage_fout);
    ___coverage_array[5241] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t2 = timelib_time_ctor();
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5242] == 0) {
    {
    fprintf(_coverage_fout, "5242\n");
    fflush(_coverage_fout);
    ___coverage_array[5242] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  _array_init(return_value, 0U);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5243] == 0) {
    {
    fprintf(_coverage_fout, "5243\n");
    fflush(_coverage_fout);
    ___coverage_array[5243] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  rs = timelib_astro_rise_set_altitude(t, longitude, latitude,
                                       - 35.0 / (double )60, 1, & ddummy,
                                       & ddummy, & rise, & set, & transit);
  switch (rs) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5169] == 0) {
    {
    fprintf(_coverage_fout, "5169\n");
    fflush(_coverage_fout);
    ___coverage_array[5169] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case -1: 
  tmp___1 = strlen("sunrise");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5170] == 0) {
    {
    fprintf(_coverage_fout, "5170\n");
    fflush(_coverage_fout);
    ___coverage_array[5170] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "sunrise", tmp___1 + 1U, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5171] == 0) {
    {
    fprintf(_coverage_fout, "5171\n");
    fflush(_coverage_fout);
    ___coverage_array[5171] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___2 = strlen("sunset");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5172] == 0) {
    {
    fprintf(_coverage_fout, "5172\n");
    fflush(_coverage_fout);
    ___coverage_array[5172] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "sunset", tmp___2 + 1U, 0);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5173] == 0) {
    {
    fprintf(_coverage_fout, "5173\n");
    fflush(_coverage_fout);
    ___coverage_array[5173] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___3 = strlen("sunrise");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5174] == 0) {
    {
    fprintf(_coverage_fout, "5174\n");
    fflush(_coverage_fout);
    ___coverage_array[5174] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "sunrise", tmp___3 + 1U, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5175] == 0) {
    {
    fprintf(_coverage_fout, "5175\n");
    fflush(_coverage_fout);
    ___coverage_array[5175] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___4 = strlen("sunset");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5176] == 0) {
    {
    fprintf(_coverage_fout, "5176\n");
    fflush(_coverage_fout);
    ___coverage_array[5176] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "sunset", tmp___4 + 1U, 1);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5177] == 0) {
    {
    fprintf(_coverage_fout, "5177\n");
    fflush(_coverage_fout);
    ___coverage_array[5177] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  t2->sse = rise;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___5 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5179] == 0) {
    {
    fprintf(_coverage_fout, "5179\n");
    fflush(_coverage_fout);
    ___coverage_array[5179] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___6 = strlen("sunrise");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5180] == 0) {
    {
    fprintf(_coverage_fout, "5180\n");
    fflush(_coverage_fout);
    ___coverage_array[5180] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "sunrise", tmp___6 + 1U, tmp___5);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5181] == 0) {
    {
    fprintf(_coverage_fout, "5181\n");
    fflush(_coverage_fout);
    ___coverage_array[5181] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t2->sse = set;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5182] == 0) {
    {
    fprintf(_coverage_fout, "5182\n");
    fflush(_coverage_fout);
    ___coverage_array[5182] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___7 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5183] == 0) {
    {
    fprintf(_coverage_fout, "5183\n");
    fflush(_coverage_fout);
    ___coverage_array[5183] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___8 = strlen("sunset");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5184] == 0) {
    {
    fprintf(_coverage_fout, "5184\n");
    fflush(_coverage_fout);
    ___coverage_array[5184] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "sunset", tmp___8 + 1U, tmp___7);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5244] == 0) {
    {
    fprintf(_coverage_fout, "5244\n");
    fflush(_coverage_fout);
    ___coverage_array[5244] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t2->sse = transit;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5245] == 0) {
    {
    fprintf(_coverage_fout, "5245\n");
    fflush(_coverage_fout);
    ___coverage_array[5245] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___9 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5246] == 0) {
    {
    fprintf(_coverage_fout, "5246\n");
    fflush(_coverage_fout);
    ___coverage_array[5246] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___10 = strlen("transit");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5247] == 0) {
    {
    fprintf(_coverage_fout, "5247\n");
    fflush(_coverage_fout);
    ___coverage_array[5247] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "transit", tmp___10 + 1U, tmp___9);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5248] == 0) {
    {
    fprintf(_coverage_fout, "5248\n");
    fflush(_coverage_fout);
    ___coverage_array[5248] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  rs = timelib_astro_rise_set_altitude(t, longitude, latitude, - 6.0, 0,
                                       & ddummy, & ddummy, & rise, & set,
                                       & transit);
  switch (rs) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5185] == 0) {
    {
    fprintf(_coverage_fout, "5185\n");
    fflush(_coverage_fout);
    ___coverage_array[5185] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case -1: 
  tmp___11 = strlen("civil_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5186] == 0) {
    {
    fprintf(_coverage_fout, "5186\n");
    fflush(_coverage_fout);
    ___coverage_array[5186] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "civil_twilight_begin", tmp___11 + 1U, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5187] == 0) {
    {
    fprintf(_coverage_fout, "5187\n");
    fflush(_coverage_fout);
    ___coverage_array[5187] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___12 = strlen("civil_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5188] == 0) {
    {
    fprintf(_coverage_fout, "5188\n");
    fflush(_coverage_fout);
    ___coverage_array[5188] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "civil_twilight_end", tmp___12 + 1U, 0);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5189] == 0) {
    {
    fprintf(_coverage_fout, "5189\n");
    fflush(_coverage_fout);
    ___coverage_array[5189] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___13 = strlen("civil_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5190] == 0) {
    {
    fprintf(_coverage_fout, "5190\n");
    fflush(_coverage_fout);
    ___coverage_array[5190] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "civil_twilight_begin", tmp___13 + 1U, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5191] == 0) {
    {
    fprintf(_coverage_fout, "5191\n");
    fflush(_coverage_fout);
    ___coverage_array[5191] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___14 = strlen("civil_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5192] == 0) {
    {
    fprintf(_coverage_fout, "5192\n");
    fflush(_coverage_fout);
    ___coverage_array[5192] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "civil_twilight_end", tmp___14 + 1U, 1);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5193] == 0) {
    {
    fprintf(_coverage_fout, "5193\n");
    fflush(_coverage_fout);
    ___coverage_array[5193] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  t2->sse = rise;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5194] == 0) {
    {
    fprintf(_coverage_fout, "5194\n");
    fflush(_coverage_fout);
    ___coverage_array[5194] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___15 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5195] == 0) {
    {
    fprintf(_coverage_fout, "5195\n");
    fflush(_coverage_fout);
    ___coverage_array[5195] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___16 = strlen("civil_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5196] == 0) {
    {
    fprintf(_coverage_fout, "5196\n");
    fflush(_coverage_fout);
    ___coverage_array[5196] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "civil_twilight_begin", tmp___16 + 1U,
                    tmp___15);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5197] == 0) {
    {
    fprintf(_coverage_fout, "5197\n");
    fflush(_coverage_fout);
    ___coverage_array[5197] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t2->sse = set;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5198] == 0) {
    {
    fprintf(_coverage_fout, "5198\n");
    fflush(_coverage_fout);
    ___coverage_array[5198] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___17 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___18 = strlen("civil_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5200] == 0) {
    {
    fprintf(_coverage_fout, "5200\n");
    fflush(_coverage_fout);
    ___coverage_array[5200] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "civil_twilight_end", tmp___18 + 1U, tmp___17);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5249] == 0) {
    {
    fprintf(_coverage_fout, "5249\n");
    fflush(_coverage_fout);
    ___coverage_array[5249] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  rs = timelib_astro_rise_set_altitude(t, longitude, latitude, - 12.0, 0,
                                       & ddummy, & ddummy, & rise, & set,
                                       & transit);
  switch (rs) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5201] == 0) {
    {
    fprintf(_coverage_fout, "5201\n");
    fflush(_coverage_fout);
    ___coverage_array[5201] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case -1: 
  tmp___19 = strlen("nautical_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5202] == 0) {
    {
    fprintf(_coverage_fout, "5202\n");
    fflush(_coverage_fout);
    ___coverage_array[5202] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "nautical_twilight_begin", tmp___19 + 1U, 0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5203] == 0) {
    {
    fprintf(_coverage_fout, "5203\n");
    fflush(_coverage_fout);
    ___coverage_array[5203] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___20 = strlen("nautical_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5204] == 0) {
    {
    fprintf(_coverage_fout, "5204\n");
    fflush(_coverage_fout);
    ___coverage_array[5204] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "nautical_twilight_end", tmp___20 + 1U, 0);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5205] == 0) {
    {
    fprintf(_coverage_fout, "5205\n");
    fflush(_coverage_fout);
    ___coverage_array[5205] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___21 = strlen("nautical_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5206] == 0) {
    {
    fprintf(_coverage_fout, "5206\n");
    fflush(_coverage_fout);
    ___coverage_array[5206] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "nautical_twilight_begin", tmp___21 + 1U, 1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___22 = strlen("nautical_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5208] == 0) {
    {
    fprintf(_coverage_fout, "5208\n");
    fflush(_coverage_fout);
    ___coverage_array[5208] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "nautical_twilight_end", tmp___22 + 1U, 1);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5209] == 0) {
    {
    fprintf(_coverage_fout, "5209\n");
    fflush(_coverage_fout);
    ___coverage_array[5209] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  t2->sse = rise;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5210] == 0) {
    {
    fprintf(_coverage_fout, "5210\n");
    fflush(_coverage_fout);
    ___coverage_array[5210] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___23 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5211] == 0) {
    {
    fprintf(_coverage_fout, "5211\n");
    fflush(_coverage_fout);
    ___coverage_array[5211] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___24 = strlen("nautical_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5212] == 0) {
    {
    fprintf(_coverage_fout, "5212\n");
    fflush(_coverage_fout);
    ___coverage_array[5212] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "nautical_twilight_begin", tmp___24 + 1U,
                    tmp___23);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5213] == 0) {
    {
    fprintf(_coverage_fout, "5213\n");
    fflush(_coverage_fout);
    ___coverage_array[5213] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t2->sse = set;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___25 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5215] == 0) {
    {
    fprintf(_coverage_fout, "5215\n");
    fflush(_coverage_fout);
    ___coverage_array[5215] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___26 = strlen("nautical_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5216] == 0) {
    {
    fprintf(_coverage_fout, "5216\n");
    fflush(_coverage_fout);
    ___coverage_array[5216] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "nautical_twilight_end", tmp___26 + 1U,
                    tmp___25);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5250] == 0) {
    {
    fprintf(_coverage_fout, "5250\n");
    fflush(_coverage_fout);
    ___coverage_array[5250] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  rs = timelib_astro_rise_set_altitude(t, longitude, latitude, - 18.0, 0,
                                       & ddummy, & ddummy, & rise, & set,
                                       & transit);
  switch (rs) {
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5217] == 0) {
    {
    fprintf(_coverage_fout, "5217\n");
    fflush(_coverage_fout);
    ___coverage_array[5217] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case -1: 
  tmp___27 = strlen("astronomical_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5218] == 0) {
    {
    fprintf(_coverage_fout, "5218\n");
    fflush(_coverage_fout);
    ___coverage_array[5218] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "astronomical_twilight_begin", tmp___27 + 1U,
                    0);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5219] == 0) {
    {
    fprintf(_coverage_fout, "5219\n");
    fflush(_coverage_fout);
    ___coverage_array[5219] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___28 = strlen("astronomical_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5220] == 0) {
    {
    fprintf(_coverage_fout, "5220\n");
    fflush(_coverage_fout);
    ___coverage_array[5220] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "astronomical_twilight_end", tmp___28 + 1U, 0);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5221] == 0) {
    {
    fprintf(_coverage_fout, "5221\n");
    fflush(_coverage_fout);
    ___coverage_array[5221] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  case 1: 
  tmp___29 = strlen("astronomical_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5222] == 0) {
    {
    fprintf(_coverage_fout, "5222\n");
    fflush(_coverage_fout);
    ___coverage_array[5222] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "astronomical_twilight_begin", tmp___29 + 1U,
                    1);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5223] == 0) {
    {
    fprintf(_coverage_fout, "5223\n");
    fflush(_coverage_fout);
    ___coverage_array[5223] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___30 = strlen("astronomical_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5224] == 0) {
    {
    fprintf(_coverage_fout, "5224\n");
    fflush(_coverage_fout);
    ___coverage_array[5224] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_bool_ex(return_value, "astronomical_twilight_end", tmp___30 + 1U, 1);
  break;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5225] == 0) {
    {
    fprintf(_coverage_fout, "5225\n");
    fflush(_coverage_fout);
    ___coverage_array[5225] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  default: 
  t2->sse = rise;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5226] == 0) {
    {
    fprintf(_coverage_fout, "5226\n");
    fflush(_coverage_fout);
    ___coverage_array[5226] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___31 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/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___32 = strlen("astronomical_twilight_begin");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5228] == 0) {
    {
    fprintf(_coverage_fout, "5228\n");
    fflush(_coverage_fout);
    ___coverage_array[5228] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "astronomical_twilight_begin", tmp___32 + 1U,
                    tmp___31);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5229] == 0) {
    {
    fprintf(_coverage_fout, "5229\n");
    fflush(_coverage_fout);
    ___coverage_array[5229] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  t2->sse = set;
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5230] == 0) {
    {
    fprintf(_coverage_fout, "5230\n");
    fflush(_coverage_fout);
    ___coverage_array[5230] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___33 = timelib_date_to_int(t2, & dummy);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5231] == 0) {
    {
    fprintf(_coverage_fout, "5231\n");
    fflush(_coverage_fout);
    ___coverage_array[5231] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  tmp___34 = strlen("astronomical_twilight_end");
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5232] == 0) {
    {
    fprintf(_coverage_fout, "5232\n");
    fflush(_coverage_fout);
    ___coverage_array[5232] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  add_assoc_long_ex(return_value, "astronomical_twilight_end", tmp___34 + 1U,
                    tmp___33);
  }
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5251] == 0) {
    {
    fprintf(_coverage_fout, "5251\n");
    fflush(_coverage_fout);
    ___coverage_array[5251] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(t);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5252] == 0) {
    {
    fprintf(_coverage_fout, "5252\n");
    fflush(_coverage_fout);
    ___coverage_array[5252] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  timelib_time_dtor(t2);
  {
  _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/php-bug-2011-03-22-0de2e61cab-991ba13174/coverage/coverage.path",
                         "a");
  if (___coverage_array[5253] == 0) {
    {
    fprintf(_coverage_fout, "5253\n");
    fflush(_coverage_fout);
    ___coverage_array[5253] = 1;
    }
  }
  fclose(_coverage_fout);
  }
  return;
}
}
