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] ;
};
struct _IO_FILE;
struct _IO_FILE;
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;
struct _IO_jump_t;
struct _IO_FILE;
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;
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;
struct _IO_cookie_file;
typedef __gnuc_va_list va_list;
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
struct obstack;
struct obstack;
typedef long Lmid_t;
struct __anonstruct_Dl_info_34 {
   char const   *dli_fname ;
   void *dli_fbase ;
   char const   *dli_sname ;
   void *dli_saddr ;
};
typedef struct __anonstruct_Dl_info_34 Dl_info;
enum __anonenum_35 {
    RTLD_DL_SYMENT = 1,
    RTLD_DL_LINKMAP = 2
} ;
enum __anonenum_36 {
    RTLD_DI_LMID = 1,
    RTLD_DI_LINKMAP = 2,
    RTLD_DI_CONFIGADDR = 3,
    RTLD_DI_SERINFO = 4,
    RTLD_DI_SERINFOSIZE = 5,
    RTLD_DI_ORIGIN = 6,
    RTLD_DI_PROFILENAME = 7,
    RTLD_DI_PROFILEOUT = 8,
    RTLD_DI_TLS_MODID = 9,
    RTLD_DI_TLS_DATA = 10,
    RTLD_DI_MAX = 10
} ;
struct __anonstruct_Dl_serpath_37 {
   char *dls_name ;
   unsigned int dls_flags ;
};
typedef struct __anonstruct_Dl_serpath_37 Dl_serpath;
struct __anonstruct_Dl_serinfo_38 {
   size_t dls_size ;
   unsigned int dls_cnt ;
   Dl_serpath dls_serpath[1] ;
};
typedef struct __anonstruct_Dl_serinfo_38 Dl_serinfo;
typedef long tsrm_intptr_t;
typedef unsigned long tsrm_uintptr_t;
struct _zend_leak_info {
   void *addr ;
   size_t size ;
   char const   *filename ;
   uint lineno ;
   char const   *orig_filename ;
   uint orig_lineno ;
};
typedef struct _zend_leak_info zend_leak_info;
struct _zend_mm_heap;
typedef struct _zend_mm_heap zend_mm_heap;
struct _zend_mm_storage;
typedef struct _zend_mm_storage zend_mm_storage;
struct _zend_mm_segment {
   size_t size ;
   struct _zend_mm_segment *next_segment ;
};
typedef struct _zend_mm_segment zend_mm_segment;
struct _zend_mm_mem_handlers {
   char const   *name ;
   zend_mm_storage *(*init)(void *params ) ;
   void (*dtor)(zend_mm_storage *storage ) ;
   void (*compact)(zend_mm_storage *storage ) ;
   zend_mm_segment *(*_alloc)(zend_mm_storage *storage , size_t size ) ;
   zend_mm_segment *(*_realloc)(zend_mm_storage *storage , zend_mm_segment *ptr , size_t size ) ;
   void (*_free)(zend_mm_storage *storage , zend_mm_segment *ptr ) ;
};
typedef struct _zend_mm_mem_handlers zend_mm_mem_handlers;
struct _zend_mm_storage {
   zend_mm_mem_handlers const   *handlers ;
   void *data ;
};
typedef unsigned char zend_bool;
typedef unsigned char zend_uchar;
typedef unsigned int zend_uint;
typedef unsigned long zend_ulong;
typedef unsigned short zend_ushort;
typedef long long zend_long64;
typedef unsigned long long zend_ulong64;
typedef long zend_intptr_t;
typedef unsigned long zend_uintptr_t;
typedef unsigned int zend_object_handle;
struct _zend_object_handlers;
typedef struct _zend_object_handlers zend_object_handlers;
struct _zend_object_value {
   zend_object_handle handle ;
   zend_object_handlers const   *handlers ;
};
typedef struct _zend_object_value zend_object_value;
typedef ulong (*hash_func_t)(char const   *arKey , uint nKeyLength );
typedef int (*compare_func_t)(void const   * , void const   * );
typedef void (*sort_func_t)(void * , size_t  , size_t  , int (*)(void const   * , void const   * ) );
typedef void (*dtor_func_t)(void *pDest );
typedef void (*copy_ctor_func_t)(void *pElement );
typedef void (*copy_ctor_param_func_t)(void *pElement , void *pParam );
struct _hashtable;
struct _hashtable;
struct bucket {
   ulong h ;
   uint nKeyLength ;
   void *pData ;
   void *pDataPtr ;
   struct bucket *pListNext ;
   struct bucket *pListLast ;
   struct bucket *pNext ;
   struct bucket *pLast ;
   char const   *arKey ;
};
typedef struct bucket Bucket;
struct _hashtable {
   uint nTableSize ;
   uint nTableMask ;
   uint nNumOfElements ;
   ulong nNextFreeElement ;
   Bucket *pInternalPointer ;
   Bucket *pListHead ;
   Bucket *pListTail ;
   Bucket **arBuckets ;
   void (*pDestructor)(void *pDest ) ;
   zend_bool persistent ;
   unsigned char nApplyCount ;
   zend_bool bApplyProtection ;
};
typedef struct _hashtable HashTable;
struct _zend_hash_key {
   char const   *arKey ;
   uint nKeyLength ;
   ulong h ;
};
typedef struct _zend_hash_key zend_hash_key;
typedef zend_bool (*merge_checker_func_t)(HashTable *target_ht , void *source_data , zend_hash_key *hash_key , void *pParam );
typedef Bucket *HashPosition;
typedef int (*apply_func_t)(void *pDest );
typedef int (*apply_func_arg_t)(void *pDest , void *argument );
typedef int (*apply_func_args_t)(void *pDest , int num_args , va_list args , zend_hash_key *hash_key );
struct _HashPointer {
   HashPosition pos ;
   ulong h ;
};
typedef struct _HashPointer HashPointer;
struct _zend_ts_hashtable {
   HashTable hash ;
   zend_uint reader ;
};
typedef struct _zend_ts_hashtable TsHashTable;
struct _zend_llist_element {
   struct _zend_llist_element *next ;
   struct _zend_llist_element *prev ;
   char data[1] ;
};
typedef struct _zend_llist_element zend_llist_element;
typedef void (*llist_dtor_func_t)(void * );
typedef int (*llist_compare_func_t)(zend_llist_element const   ** , zend_llist_element const   ** );
typedef void (*llist_apply_with_args_func_t)(void *data , int num_args , va_list args );
typedef void (*llist_apply_with_arg_func_t)(void *data , void *arg );
typedef void (*llist_apply_func_t)(void * );
struct _zend_llist {
   zend_llist_element *head ;
   zend_llist_element *tail ;
   size_t count ;
   size_t size ;
   void (*dtor)(void * ) ;
   unsigned char persistent ;
   zend_llist_element *traverse_ptr ;
};
typedef struct _zend_llist zend_llist;
typedef zend_llist_element *zend_llist_position;
struct _zval_struct;
typedef struct _zval_struct zval;
struct _zend_class_entry;
typedef struct _zend_class_entry zend_class_entry;
struct _zend_guard {
   zend_bool in_get ;
   zend_bool in_set ;
   zend_bool in_unset ;
   zend_bool in_isset ;
   zend_bool dummy ;
};
typedef struct _zend_guard zend_guard;
struct _zend_object {
   zend_class_entry *ce ;
   HashTable *properties ;
   zval **properties_table ;
   HashTable *guards ;
};
typedef struct _zend_object zend_object;
union _zend_function;
union _zend_function;
struct _zend_property_info;
struct _zend_property_info;
struct _zend_literal;
struct _zend_literal;
typedef zval *(*zend_object_read_property_t)(zval *object , zval *member , int type , struct _zend_literal  const  *key );
typedef zval *(*zend_object_read_dimension_t)(zval *object , zval *offset , int type );
typedef void (*zend_object_write_property_t)(zval *object , zval *member , zval *value , struct _zend_literal  const  *key );
typedef void (*zend_object_write_dimension_t)(zval *object , zval *offset , zval *value );
typedef zval **(*zend_object_get_property_ptr_ptr_t)(zval *object , zval *member , struct _zend_literal  const  *key );
typedef void (*zend_object_set_t)(zval **object , zval *value );
typedef zval *(*zend_object_get_t)(zval *object );
typedef int (*zend_object_has_property_t)(zval *object , zval *member , int has_set_exists , struct _zend_literal  const  *key );
typedef int (*zend_object_has_dimension_t)(zval *object , zval *member , int check_empty );
typedef void (*zend_object_unset_property_t)(zval *object , zval *member , struct _zend_literal  const  *key );
typedef void (*zend_object_unset_dimension_t)(zval *object , zval *offset );
typedef HashTable *(*zend_object_get_properties_t)(zval *object );
typedef HashTable *(*zend_object_get_debug_info_t)(zval *object , int *is_temp );
typedef int (*zend_object_call_method_t)(char const   *method , int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used );
typedef union _zend_function *(*zend_object_get_method_t)(zval **object_ptr , char *method , int method_len , struct _zend_literal  const  *key );
typedef union _zend_function *(*zend_object_get_constructor_t)(zval *object );
typedef void (*zend_object_add_ref_t)(zval *object );
typedef void (*zend_object_del_ref_t)(zval *object );
typedef void (*zend_object_delete_obj_t)(zval *object );
typedef zend_object_value (*zend_object_clone_obj_t)(zval *object );
typedef zend_class_entry *(*zend_object_get_class_entry_t)(zval const   *object );
typedef int (*zend_object_get_class_name_t)(zval const   *object , char const   **class_name , zend_uint *class_name_len , int parent );
typedef int (*zend_object_compare_t)(zval *object1 , zval *object2 );
typedef int (*zend_object_cast_t)(zval *readobj , zval *retval , int type );
typedef int (*zend_object_count_elements_t)(zval *object , long *count );
typedef int (*zend_object_get_closure_t)(zval *obj , zend_class_entry **ce_ptr , union _zend_function **fptr_ptr , zval **zobj_ptr );
typedef HashTable *(*zend_object_get_gc_t)(zval *object , zval ***table , int *n );
struct _zend_object_handlers {
   void (*add_ref)(zval *object ) ;
   void (*del_ref)(zval *object ) ;
   zend_object_value (*clone_obj)(zval *object ) ;
   zval *(*read_property)(zval *object , zval *member , int type , struct _zend_literal  const  *key ) ;
   void (*write_property)(zval *object , zval *member , zval *value , struct _zend_literal  const  *key ) ;
   zval *(*read_dimension)(zval *object , zval *offset , int type ) ;
   void (*write_dimension)(zval *object , zval *offset , zval *value ) ;
   zval **(*get_property_ptr_ptr)(zval *object , zval *member , struct _zend_literal  const  *key ) ;
   zval *(*get)(zval *object ) ;
   void (*set)(zval **object , zval *value ) ;
   int (*has_property)(zval *object , zval *member , int has_set_exists , struct _zend_literal  const  *key ) ;
   void (*unset_property)(zval *object , zval *member , struct _zend_literal  const  *key ) ;
   int (*has_dimension)(zval *object , zval *member , int check_empty ) ;
   void (*unset_dimension)(zval *object , zval *offset ) ;
   HashTable *(*get_properties)(zval *object ) ;
   union _zend_function *(*get_method)(zval **object_ptr , char *method , int method_len , struct _zend_literal  const  *key ) ;
   int (*call_method)(char const   *method , int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
   union _zend_function *(*get_constructor)(zval *object ) ;
   zend_class_entry *(*get_class_entry)(zval const   *object ) ;
   int (*get_class_name)(zval const   *object , char const   **class_name , zend_uint *class_name_len , int parent ) ;
   int (*compare_objects)(zval *object1 , zval *object2 ) ;
   int (*cast_object)(zval *readobj , zval *retval , int type ) ;
   int (*count_elements)(zval *object , long *count ) ;
   HashTable *(*get_debug_info)(zval *object , int *is_temp ) ;
   int (*get_closure)(zval *obj , zend_class_entry **ce_ptr , union _zend_function **fptr_ptr , zval **zobj_ptr ) ;
   HashTable *(*get_gc)(zval *object , zval ***table , int *n ) ;
};
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 ;
};
union _zend_function;
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_serialize_data;
struct _zend_unserialize_data;
struct _zend_unserialize_data;
typedef struct _zend_serialize_data zend_serialize_data;
typedef struct _zend_unserialize_data zend_unserialize_data;
struct _zend_trait_method_reference {
   char const   *method_name ;
   unsigned int mname_len ;
   zend_class_entry *ce ;
   char const   *class_name ;
   unsigned int cname_len ;
};
typedef struct _zend_trait_method_reference zend_trait_method_reference;
struct _zend_trait_precedence {
   zend_trait_method_reference *trait_method ;
   zend_class_entry **exclude_from_classes ;
   union _zend_function *function ;
};
typedef struct _zend_trait_precedence zend_trait_precedence;
struct _zend_trait_alias {
   zend_trait_method_reference *trait_method ;
   char const   *alias ;
   unsigned int alias_len ;
   zend_uint modifiers ;
   union _zend_function *function ;
};
typedef struct _zend_trait_alias zend_trait_alias;
struct __anonstruct_user_41 {
   char const   *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char const   *doc_comment ;
   zend_uint doc_comment_len ;
};
struct _zend_function_entry;
struct _zend_module_entry;
struct __anonstruct_internal_42 {
   struct _zend_function_entry  const  *builtin_functions ;
   struct _zend_module_entry *module ;
};
union __anonunion_info_40 {
   struct __anonstruct_user_41 user ;
   struct __anonstruct_internal_42 internal ;
};
struct _zend_class_entry {
   char type ;
   char const   *name ;
   zend_uint name_length ;
   struct _zend_class_entry *parent ;
   int refcount ;
   zend_uint ce_flags ;
   HashTable function_table ;
   HashTable properties_info ;
   zval **default_properties_table ;
   zval **default_static_members_table ;
   zval **static_members_table ;
   HashTable constants_table ;
   int default_properties_count ;
   int default_static_members_count ;
   union _zend_function *constructor ;
   union _zend_function *destructor ;
   union _zend_function *clone ;
   union _zend_function *__get ;
   union _zend_function *__set ;
   union _zend_function *__unset ;
   union _zend_function *__isset ;
   union _zend_function *__call ;
   union _zend_function *__callstatic ;
   union _zend_function *__tostring ;
   union _zend_function *serialize_func ;
   union _zend_function *unserialize_func ;
   zend_class_iterator_funcs iterator_funcs ;
   zend_object_value (*create_object)(zend_class_entry *class_type ) ;
   zend_object_iterator *(*get_iterator)(zend_class_entry *ce , zval *object , int by_ref ) ;
   int (*interface_gets_implemented)(zend_class_entry *iface , zend_class_entry *class_type ) ;
   union _zend_function *(*get_static_method)(zend_class_entry *ce , char *method , int method_len ) ;
   int (*serialize)(zval *object , unsigned char **buffer , zend_uint *buf_len , zend_serialize_data *data ) ;
   int (*unserialize)(zval **object , zend_class_entry *ce , unsigned char const   *buf , zend_uint buf_len , zend_unserialize_data *data ) ;
   zend_class_entry **interfaces ;
   zend_uint num_interfaces ;
   zend_class_entry **traits ;
   zend_uint num_traits ;
   zend_trait_alias **trait_aliases ;
   zend_trait_precedence **trait_precedences ;
   union __anonunion_info_40 info ;
};
typedef size_t (*zend_stream_fsizer_t)(void *handle );
typedef size_t (*zend_stream_reader_t)(void *handle , char *buf , size_t len );
typedef void (*zend_stream_closer_t)(void *handle );
enum __anonenum_zend_stream_type_43 {
    ZEND_HANDLE_FILENAME = 0,
    ZEND_HANDLE_FD = 1,
    ZEND_HANDLE_FP = 2,
    ZEND_HANDLE_STREAM = 3,
    ZEND_HANDLE_MAPPED = 4
} ;
typedef enum __anonenum_zend_stream_type_43 zend_stream_type;
struct _zend_mmap {
   size_t len ;
   size_t pos ;
   void *map ;
   char *buf ;
   void *old_handle ;
   void (*old_closer)(void *handle ) ;
};
typedef struct _zend_mmap zend_mmap;
struct _zend_stream {
   void *handle ;
   int isatty ;
   zend_mmap mmap ;
   size_t (*reader)(void *handle , char *buf , size_t len ) ;
   size_t (*fsizer)(void *handle ) ;
   void (*closer)(void *handle ) ;
};
typedef struct _zend_stream zend_stream;
union __anonunion_handle_44 {
   int fd ;
   FILE *fp ;
   zend_stream stream ;
};
struct _zend_file_handle {
   zend_stream_type type ;
   char const   *filename ;
   char *opened_path ;
   union __anonunion_handle_44 handle ;
   zend_bool free_filename ;
};
typedef struct _zend_file_handle zend_file_handle;
struct _zend_utility_functions {
   void ( /* format attribute */  (*error_function))(int type , char const   *error_filename , uint error_lineno , char const   *format , va_list args ) ;
   int ( /* format attribute */  (*printf_function))(char const   *format  , ...) ;
   int (*write_function)(char const   *str , uint str_length ) ;
   FILE *(*fopen_function)(char const   *filename , char **opened_path ) ;
   void (*message_handler)(long message , void const   *data ) ;
   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 const   *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;
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 const   *name ;
   int name_length ;
   ulong h ;
   int offset ;
   char const   *doc_comment ;
   int doc_comment_len ;
   zend_class_entry *ce ;
};
typedef struct _zend_property_info zend_property_info;
struct _zend_arg_info {
   char const   *name ;
   zend_uint name_len ;
   char const   *class_name ;
   zend_uint class_name_len ;
   zend_uchar type_hint ;
   zend_bool allow_null ;
   zend_bool pass_by_reference ;
};
typedef struct _zend_arg_info zend_arg_info;
struct _zend_internal_function_info {
   char const   *_name ;
   zend_uint _name_len ;
   char const   *_class_name ;
   zend_uint required_num_args ;
   zend_uchar _type_hint ;
   zend_bool return_reference ;
   zend_bool pass_rest_by_reference ;
};
typedef struct _zend_internal_function_info zend_internal_function_info;
struct _zend_compiled_variable {
   char const   *name ;
   int name_len ;
   ulong hash_value ;
};
typedef struct _zend_compiled_variable zend_compiled_variable;
struct _zend_op_array {
   zend_uchar type ;
   char const   *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
   zend_uint *refcount ;
   zend_op *opcodes ;
   zend_uint last ;
   zend_compiled_variable *vars ;
   int last_var ;
   zend_uint T ;
   zend_brk_cont_element *brk_cont_array ;
   int last_brk_cont ;
   zend_try_catch_element *try_catch_array ;
   int last_try_catch ;
   HashTable *static_variables ;
   zend_uint this_var ;
   char const   *filename ;
   zend_uint line_start ;
   zend_uint line_end ;
   char const   *doc_comment ;
   zend_uint doc_comment_len ;
   zend_uint early_binding ;
   zend_literal *literals ;
   int last_literal ;
   void **run_time_cache ;
   int last_cache_slot ;
   void *reserved[4] ;
};
struct _zend_internal_function {
   zend_uchar type ;
   char const   *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
   void (*handler)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
   struct _zend_module_entry *module ;
};
typedef struct _zend_internal_function zend_internal_function;
struct __anonstruct_common_50 {
   zend_uchar type ;
   char const   *function_name ;
   zend_class_entry *scope ;
   zend_uint fn_flags ;
   union _zend_function *prototype ;
   zend_uint num_args ;
   zend_uint required_num_args ;
   zend_arg_info *arg_info ;
};
union _zend_function {
   zend_uchar type ;
   struct __anonstruct_common_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;
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 parse_error ;
   zend_bool in_compilation ;
   zend_bool short_tags ;
   zend_bool asp_tags ;
   zend_declarables declarables ;
   zend_bool unclean_shutdown ;
   zend_bool ini_parser_unbuffered_errors ;
   zend_llist open_files ;
   long catch_begin ;
   struct _zend_ini_parser_param *ini_parser_param ;
   int interactive ;
   zend_uint start_lineno ;
   zend_bool increment_lineno ;
   znode implementing_class ;
   zend_uint access_type ;
   char *doc_comment ;
   zend_uint doc_comment_len ;
   zend_uint compiler_options ;
   zval *current_namespace ;
   HashTable *current_import ;
   zend_bool in_namespace ;
   zend_bool has_bracketed_namespaces ;
   zend_compiler_context context ;
   zend_stack context_stack ;
   char *interned_strings_start ;
   char *interned_strings_end ;
   char *interned_strings_top ;
   char *interned_strings_snapshot_top ;
   HashTable interned_strings ;
   zend_encoding const   **script_encoding_list ;
   size_t script_encoding_list_size ;
   zend_bool multibyte ;
   zend_bool detect_unicode ;
   zend_bool encoding_declared ;
};
struct _zend_executor_globals {
   zval **return_value_ptr_ptr ;
   zval uninitialized_zval ;
   zval *uninitialized_zval_ptr ;
   zval error_zval ;
   zval *error_zval_ptr ;
   zend_ptr_stack arg_types_stack ;
   HashTable *symtable_cache[32] ;
   HashTable **symtable_cache_limit ;
   HashTable **symtable_cache_ptr ;
   zend_op **opline_ptr ;
   HashTable *active_symbol_table ;
   HashTable symbol_table ;
   HashTable included_files ;
   jmp_buf *bailout ;
   int error_reporting ;
   int orig_error_reporting ;
   int exit_status ;
   zend_op_array *active_op_array ;
   HashTable *function_table ;
   HashTable *class_table ;
   HashTable *zend_constants ;
   zend_class_entry *scope ;
   zend_class_entry *called_scope ;
   zval *This ;
   long precision ;
   int ticks_count ;
   zend_bool in_execution ;
   HashTable *in_autoload ;
   zend_function *autoload_func ;
   zend_bool full_tables_cleanup ;
   zend_bool no_extensions ;
   HashTable regular_list ;
   HashTable persistent_list ;
   zend_vm_stack argument_stack ;
   int user_error_handler_error_reporting ;
   zval *user_error_handler ;
   zval *user_exception_handler ;
   zend_stack user_error_handlers_error_reporting ;
   zend_ptr_stack user_error_handlers ;
   zend_ptr_stack user_exception_handlers ;
   zend_error_handling_t error_handling ;
   zend_class_entry *exception_class ;
   int timeout_seconds ;
   int lambda_count ;
   HashTable *ini_directives ;
   HashTable *modified_ini_directives ;
   zend_ini_entry *error_reporting_ini_entry ;
   zend_objects_store objects_store ;
   zval *exception ;
   zval *prev_exception ;
   zend_op *opline_before_exception ;
   zend_op exception_op[3] ;
   struct _zend_execute_data *current_execute_data ;
   struct _zend_module_entry *current_module ;
   zend_property_info std_property_info ;
   zend_bool active ;
   zend_op *start_op ;
   void *saved_fpu_cw_ptr ;
   fpu_control_t saved_fpu_cw ;
   void *reserved[4] ;
};
struct _zend_ini_scanner_globals {
   zend_file_handle *yy_in ;
   zend_file_handle *yy_out ;
   unsigned int yy_leng ;
   unsigned char *yy_start ;
   unsigned char *yy_text ;
   unsigned char *yy_cursor ;
   unsigned char *yy_marker ;
   unsigned char *yy_limit ;
   int yy_state ;
   zend_stack state_stack ;
   char *filename ;
   int lineno ;
   int scanner_mode ;
};
struct _zend_php_scanner_globals {
   zend_file_handle *yy_in ;
   zend_file_handle *yy_out ;
   unsigned int yy_leng ;
   unsigned char *yy_start ;
   unsigned char *yy_text ;
   unsigned char *yy_cursor ;
   unsigned char *yy_marker ;
   unsigned char *yy_limit ;
   int yy_state ;
   zend_stack state_stack ;
   unsigned char *script_org ;
   size_t script_org_size ;
   unsigned char *script_filtered ;
   size_t script_filtered_size ;
   size_t (*input_filter)(unsigned char **str , size_t *str_length , unsigned char const   *buf , size_t length ) ;
   size_t (*output_filter)(unsigned char **str , size_t *str_length , unsigned char const   *buf , size_t length ) ;
   zend_encoding const   *script_encoding ;
};
typedef int (*unary_op_type)(zval * , zval * );
typedef int (*binary_op_type)(zval * , zval * , zval * );
typedef zend_bool (*zend_auto_global_callback)(char const   *name , uint name_len );
struct _zend_auto_global {
   char const   *name ;
   uint name_len ;
   zend_bool (*auto_global_callback)(char const   *name , uint name_len ) ;
   zend_bool jit ;
   zend_bool armed ;
};
typedef struct _zend_auto_global zend_auto_global;
struct _zend_ini_entry;
typedef struct _zend_module_entry zend_module_entry;
struct _zend_module_dep;
typedef struct _zend_module_dep zend_module_dep;
struct _zend_module_entry {
   unsigned short size ;
   unsigned int zend_api ;
   unsigned char zend_debug ;
   unsigned char zts ;
   struct _zend_ini_entry  const  *ini_entry ;
   struct _zend_module_dep  const  *deps ;
   char const   *name ;
   struct _zend_function_entry  const  *functions ;
   int (*module_startup_func)(int type , int module_number ) ;
   int (*module_shutdown_func)(int type , int module_number ) ;
   int (*request_startup_func)(int type , int module_number ) ;
   int (*request_shutdown_func)(int type , int module_number ) ;
   void (*info_func)(zend_module_entry *zend_module ) ;
   char const   *version ;
   size_t globals_size ;
   void *globals_ptr ;
   void (*globals_ctor)(void *global ) ;
   void (*globals_dtor)(void *global ) ;
   int (*post_deactivate_func)(void) ;
   int module_started ;
   unsigned char type ;
   void *handle ;
   int module_number ;
   char const   *build_id ;
};
struct _zend_module_dep {
   char const   *name ;
   char const   *rel ;
   char const   *version ;
   unsigned char type ;
};
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 const   *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 ;
   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 ) ;
   int (*stream_metadata)(php_stream_wrapper *wrapper , char *url , int options , void *value , 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 ;
};
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 _php_tick_function_entry;
struct _arg_separators {
   char *output ;
   char *input ;
};
typedef struct _arg_separators arg_separators;
struct _php_core_globals {
   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 *php_binary ;
   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 ;
   long max_input_vars ;
   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 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 ) ;
   double (*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;
struct tm;
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 ;
   unsigned int serialize_lock ;
   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;
struct _php_shutdown_function_entry {
   zval **arguments ;
   int arg_count ;
};
typedef struct _php_shutdown_function_entry php_shutdown_function_entry;
struct lconv;
struct __anonstruct_PHP_MD5_CTX_90 {
   php_uint32 lo ;
   php_uint32 hi ;
   php_uint32 a ;
   php_uint32 b ;
   php_uint32 c ;
   php_uint32 d ;
   unsigned char buffer[64] ;
   php_uint32 block[16] ;
};
typedef struct __anonstruct_PHP_MD5_CTX_90 PHP_MD5_CTX;
struct __anonstruct_PHP_SHA1_CTX_91 {
   php_uint32 state[5] ;
   php_uint32 count[2] ;
   unsigned char buffer[64] ;
};
typedef struct __anonstruct_PHP_SHA1_CTX_91 PHP_SHA1_CTX;
enum _php_meta_tags_token {
    TOK_EOF = 0,
    TOK_OPENTAG = 1,
    TOK_CLOSETAG = 2,
    TOK_SLASH = 3,
    TOK_EQUAL = 4,
    TOK_SPACE = 5,
    TOK_ID = 6,
    TOK_STRING = 7,
    TOK_OTHER = 8
} ;
typedef enum _php_meta_tags_token php_meta_tags_token;
struct _php_meta_tags_data {
   php_stream *stream ;
   int ulc ;
   int lc ;
   char *input_buffer ;
   char *token_data ;
   int token_len ;
   int in_meta ;
};
typedef struct _php_meta_tags_data php_meta_tags_data;
struct __anonstruct_php_file_globals_92 {
   int pclose_ret ;
   size_t def_chunk_size ;
   long auto_detect_line_endings ;
   long default_socket_timeout ;
   char *user_agent ;
   char *from_address ;
   char *user_stream_current_filename ;
   php_stream_context *default_context ;
   HashTable *stream_wrappers ;
   HashTable *stream_filters ;
   HashTable *wrapper_errors ;
};
typedef struct __anonstruct_php_file_globals_92 php_file_globals;
struct php_url {
   char *scheme ;
   char *user ;
   char *pass ;
   char *host ;
   unsigned short port ;
   char *path ;
   char *query ;
   char *fragment ;
};
typedef struct php_url php_url;
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;
enum __anonenum_93 {
    IPPROTO_IP = 0,
    IPPROTO_HOPOPTS = 0,
    IPPROTO_ICMP = 1,
    IPPROTO_IGMP = 2,
    IPPROTO_IPIP = 4,
    IPPROTO_TCP = 6,
    IPPROTO_EGP = 8,
    IPPROTO_PUP = 12,
    IPPROTO_UDP = 17,
    IPPROTO_IDP = 22,
    IPPROTO_TP = 29,
    IPPROTO_DCCP = 33,
    IPPROTO_IPV6 = 41,
    IPPROTO_ROUTING = 43,
    IPPROTO_FRAGMENT = 44,
    IPPROTO_RSVP = 46,
    IPPROTO_GRE = 47,
    IPPROTO_ESP = 50,
    IPPROTO_AH = 51,
    IPPROTO_ICMPV6 = 58,
    IPPROTO_NONE = 59,
    IPPROTO_DSTOPTS = 60,
    IPPROTO_MTP = 92,
    IPPROTO_ENCAP = 98,
    IPPROTO_PIM = 103,
    IPPROTO_COMP = 108,
    IPPROTO_SCTP = 132,
    IPPROTO_UDPLITE = 136,
    IPPROTO_RAW = 255,
    IPPROTO_MAX = 256
} ;
typedef uint16_t in_port_t;
enum __anonenum_94 {
    IPPORT_ECHO = 7,
    IPPORT_DISCARD = 9,
    IPPORT_SYSTAT = 11,
    IPPORT_DAYTIME = 13,
    IPPORT_NETSTAT = 15,
    IPPORT_FTP = 21,
    IPPORT_TELNET = 23,
    IPPORT_SMTP = 25,
    IPPORT_TIMESERVER = 37,
    IPPORT_NAMESERVER = 42,
    IPPORT_WHOIS = 43,
    IPPORT_MTP = 57,
    IPPORT_TFTP = 69,
    IPPORT_RJE = 77,
    IPPORT_FINGER = 79,
    IPPORT_TTYLINK = 87,
    IPPORT_SUPDUP = 95,
    IPPORT_EXECSERVER = 512,
    IPPORT_LOGINSERVER = 513,
    IPPORT_CMDSERVER = 514,
    IPPORT_EFSSERVER = 520,
    IPPORT_BIFFUDP = 512,
    IPPORT_WHOSERVER = 513,
    IPPORT_ROUTESERVER = 520,
    IPPORT_RESERVED = 1024,
    IPPORT_USERRESERVED = 5000
} ;
typedef uint32_t in_addr_t;
struct in_addr {
   in_addr_t s_addr ;
};
union __anonunion___in6_u_95 {
   uint8_t __u6_addr8[16] ;
   uint16_t __u6_addr16[8] ;
   uint32_t __u6_addr32[4] ;
};
struct in6_addr {
   union __anonunion___in6_u_95 __in6_u ;
};
struct sockaddr_in {
   sa_family_t sin_family ;
   in_port_t sin_port ;
   struct in_addr sin_addr ;
   unsigned char sin_zero[((sizeof(struct sockaddr ) - sizeof(unsigned short )) - sizeof(in_port_t )) - sizeof(struct in_addr )] ;
};
struct sockaddr_in6 {
   sa_family_t sin6_family ;
   in_port_t sin6_port ;
   uint32_t sin6_flowinfo ;
   struct in6_addr sin6_addr ;
   uint32_t sin6_scope_id ;
};
struct ip_mreq {
   struct in_addr imr_multiaddr ;
   struct in_addr imr_interface ;
};
struct ip_mreq_source {
   struct in_addr imr_multiaddr ;
   struct in_addr imr_interface ;
   struct in_addr imr_sourceaddr ;
};
struct ipv6_mreq {
   struct in6_addr ipv6mr_multiaddr ;
   unsigned int ipv6mr_interface ;
};
struct group_req {
   uint32_t gr_interface ;
   struct sockaddr_storage gr_group ;
};
struct group_source_req {
   uint32_t gsr_interface ;
   struct sockaddr_storage gsr_group ;
   struct sockaddr_storage gsr_source ;
};
struct ip_msfilter {
   struct in_addr imsf_multiaddr ;
   struct in_addr imsf_interface ;
   uint32_t imsf_fmode ;
   uint32_t imsf_numsrc ;
   struct in_addr imsf_slist[1] ;
};
struct group_filter {
   uint32_t gf_interface ;
   struct sockaddr_storage gf_group ;
   uint32_t gf_fmode ;
   uint32_t gf_numsrc ;
   struct sockaddr_storage gf_slist[1] ;
};
struct ip_opts {
   struct in_addr ip_dst ;
   char ip_opts[40] ;
};
struct ip_mreqn {
   struct in_addr imr_multiaddr ;
   struct in_addr imr_address ;
   int imr_ifindex ;
};
struct in_pktinfo {
   int ipi_ifindex ;
   struct in_addr ipi_spec_dst ;
   struct in_addr ipi_addr ;
};
struct in6_pktinfo {
   struct in6_addr ipi6_addr ;
   unsigned int ipi6_ifindex ;
};
struct ip6_mtuinfo {
   struct sockaddr_in6 ip6m_addr ;
   uint32_t ip6m_mtu ;
};
typedef int php_socket_t;
typedef unsigned long nfds_t;
struct pollfd {
   int fd ;
   short events ;
   short revents ;
};
typedef struct pollfd php_pollfd;
typedef struct sockaddr_storage php_sockaddr_storage;
struct _php_netstream_data_t {
   php_socket_t socket ;
   char is_blocked ;
   struct timeval timeout ;
   char timeout_event ;
   size_t ownsize ;
};
typedef struct _php_netstream_data_t php_netstream_data_t;
enum __anonenum_image_filetype_96 {
    IMAGE_FILETYPE_UNKNOWN = 0,
    IMAGE_FILETYPE_GIF = 1,
    IMAGE_FILETYPE_JPEG = 2,
    IMAGE_FILETYPE_PNG = 3,
    IMAGE_FILETYPE_SWF = 4,
    IMAGE_FILETYPE_PSD = 5,
    IMAGE_FILETYPE_BMP = 6,
    IMAGE_FILETYPE_TIFF_II = 7,
    IMAGE_FILETYPE_TIFF_MM = 8,
    IMAGE_FILETYPE_JPC = 9,
    IMAGE_FILETYPE_JP2 = 10,
    IMAGE_FILETYPE_JPX = 11,
    IMAGE_FILETYPE_JB2 = 12,
    IMAGE_FILETYPE_SWC = 13,
    IMAGE_FILETYPE_IFF = 14,
    IMAGE_FILETYPE_WBMP = 15,
    IMAGE_FILETYPE_XBM = 16,
    IMAGE_FILETYPE_ICO = 17,
    IMAGE_FILETYPE_COUNT = 18
} ;
typedef enum __anonenum_image_filetype_96 image_filetype;
typedef HashTable *php_serialize_data_t;
struct php_unserialize_data {
   void *first ;
   void *last ;
   void *first_dtor ;
   void *last_dtor ;
};
typedef struct php_unserialize_data *php_unserialize_data_t;
struct __anonstruct_php_lcg_globals_97 {
   php_int32 s1 ;
   php_int32 s2 ;
   int seeded ;
};
typedef struct __anonstruct_php_lcg_globals_97 php_lcg_globals;
struct _zend_array_globals {
   int *multisort_flags[2] ;
   int (*compare_func)(zval *result , zval *op1 , zval *op2 ) ;
};
typedef struct _zend_array_globals zend_array_globals;
struct _opt_struct {
   char opt_char ;
   int need_param ;
   char *opt_name ;
};
typedef struct _opt_struct opt_struct;
typedef unsigned long long php_hash_uint64;
typedef unsigned int php_hash_uint32;
typedef void (*php_hash_init_func_t)(void *context );
typedef void (*php_hash_update_func_t)(void *context , unsigned char const   *buf , unsigned int count );
typedef void (*php_hash_final_func_t)(unsigned char *digest , void *context );
typedef int (*php_hash_copy_func_t)(void const   *ops , void *orig_context , void *dest_context );
struct _php_hash_ops {
   void (*hash_init)(void *context ) ;
   void (*hash_update)(void *context , unsigned char const   *buf , unsigned int count ) ;
   void (*hash_final)(unsigned char *digest , void *context ) ;
   int (*hash_copy)(void const   *ops , void *orig_context , void *dest_context ) ;
   int digest_size ;
   int block_size ;
   int context_size ;
};
typedef struct _php_hash_ops php_hash_ops;
struct _php_hash_data {
   php_hash_ops const   *ops ;
   void *context ;
   long options ;
   unsigned char *key ;
};
typedef struct _php_hash_data php_hash_data;
struct ps_module_struct {
   char const   *s_name ;
   int (*s_open)(void **mod_data , char const   *save_path , char const   *session_name ) ;
   int (*s_close)(void **mod_data ) ;
   int (*s_read)(void **mod_data , char const   *key , char **val , int *vallen ) ;
   int (*s_write)(void **mod_data , char const   *key , char const   *val , int vallen ) ;
   int (*s_destroy)(void **mod_data , char const   *key ) ;
   int (*s_gc)(void **mod_data , int maxlifetime , int *nrdels ) ;
   char *(*s_create_sid)(void **mod_data , int *newlen ) ;
};
typedef struct ps_module_struct ps_module;
enum __anonenum_php_session_status_98 {
    php_session_disabled = 0,
    php_session_none = 1,
    php_session_active = 2
} ;
typedef enum __anonenum_php_session_status_98 php_session_status;
struct _php_session_rfc1867_progress {
   size_t sname_len ;
   zval sid ;
   smart_str key ;
   long update_step ;
   long next_update ;
   double next_update_time ;
   zend_bool cancel_upload ;
   zend_bool apply_trans_sid ;
   size_t content_length ;
   zval *data ;
   zval *post_bytes_processed ;
   zval *files ;
   zval *current_file ;
   zval *current_file_bytes_processed ;
};
typedef struct _php_session_rfc1867_progress php_session_rfc1867_progress;
struct __anonstruct_name_100 {
   zval *ps_open ;
   zval *ps_close ;
   zval *ps_read ;
   zval *ps_write ;
   zval *ps_destroy ;
   zval *ps_gc ;
};
union __anonunion_mod_user_names_99 {
   zval *names[6] ;
   struct __anonstruct_name_100 name ;
};
struct ps_serializer_struct;
struct _php_ps_globals {
   char *save_path ;
   char *session_name ;
   char *id ;
   char *extern_referer_chk ;
   char *entropy_file ;
   char *cache_limiter ;
   long entropy_length ;
   long cookie_lifetime ;
   char *cookie_path ;
   char *cookie_domain ;
   zend_bool cookie_secure ;
   zend_bool cookie_httponly ;
   ps_module *mod ;
   ps_module *default_mod ;
   void *mod_data ;
   php_session_status session_status ;
   long gc_probability ;
   long gc_divisor ;
   long gc_maxlifetime ;
   int module_number ;
   long cache_expire ;
   union __anonunion_mod_user_names_99 mod_user_names ;
   int mod_user_implemented ;
   int mod_user_is_open ;
   struct ps_serializer_struct  const  *serializer ;
   zval *http_session_vars ;
   zend_bool auto_start ;
   zend_bool use_cookies ;
   zend_bool use_only_cookies ;
   zend_bool use_trans_sid ;
   zend_bool apply_trans_sid ;
   long hash_func ;
   php_hash_ops *hash_ops ;
   long hash_bits_per_character ;
   int send_cookie ;
   int define_sid ;
   zend_bool invalid_session_id ;
   php_session_rfc1867_progress *rfc1867_progress ;
   zend_bool rfc1867_enabled ;
   zend_bool rfc1867_cleanup ;
   smart_str rfc1867_prefix ;
   smart_str rfc1867_name ;
   long rfc1867_freq ;
   double rfc1867_min_freq ;
};
typedef struct _php_ps_globals php_ps_globals;
typedef php_ps_globals zend_ps_globals;
struct ps_serializer_struct {
   char const   *name ;
   int (*encode)(char **newstr , int *newlen ) ;
   int (*decode)(char const   *val , int vallen ) ;
};
typedef struct ps_serializer_struct ps_serializer;
struct yy_buffer_state;
typedef struct yy_buffer_state *YY_BUFFER_STATE;
struct _zend_lex_state {
   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 ;
   zend_file_handle *in ;
   uint lineno ;
   char *filename ;
   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 struct _zend_lex_state zend_lex_state;
enum yytokentype {
    END = 0,
    T_REQUIRE_ONCE = 258,
    T_REQUIRE = 259,
    T_EVAL = 260,
    T_INCLUDE_ONCE = 261,
    T_INCLUDE = 262,
    T_LOGICAL_OR = 263,
    T_LOGICAL_XOR = 264,
    T_LOGICAL_AND = 265,
    T_PRINT = 266,
    T_SR_EQUAL = 267,
    T_SL_EQUAL = 268,
    T_XOR_EQUAL = 269,
    T_OR_EQUAL = 270,
    T_AND_EQUAL = 271,
    T_MOD_EQUAL = 272,
    T_CONCAT_EQUAL = 273,
    T_DIV_EQUAL = 274,
    T_MUL_EQUAL = 275,
    T_MINUS_EQUAL = 276,
    T_PLUS_EQUAL = 277,
    T_BOOLEAN_OR = 278,
    T_BOOLEAN_AND = 279,
    T_IS_NOT_IDENTICAL = 280,
    T_IS_IDENTICAL = 281,
    T_IS_NOT_EQUAL = 282,
    T_IS_EQUAL = 283,
    T_IS_GREATER_OR_EQUAL = 284,
    T_IS_SMALLER_OR_EQUAL = 285,
    T_SR = 286,
    T_SL = 287,
    T_INSTANCEOF = 288,
    T_UNSET_CAST = 289,
    T_BOOL_CAST = 290,
    T_OBJECT_CAST = 291,
    T_ARRAY_CAST = 292,
    T_STRING_CAST = 293,
    T_DOUBLE_CAST = 294,
    T_INT_CAST = 295,
    T_DEC = 296,
    T_INC = 297,
    T_CLONE = 298,
    T_NEW = 299,
    T_EXIT = 300,
    T_IF = 301,
    T_ELSEIF = 302,
    T_ELSE = 303,
    T_ENDIF = 304,
    T_LNUMBER = 305,
    T_DNUMBER = 306,
    T_STRING = 307,
    T_STRING_VARNAME = 308,
    T_VARIABLE = 309,
    T_NUM_STRING = 310,
    T_INLINE_HTML = 311,
    T_CHARACTER = 312,
    T_BAD_CHARACTER = 313,
    T_ENCAPSED_AND_WHITESPACE = 314,
    T_CONSTANT_ENCAPSED_STRING = 315,
    T_ECHO = 316,
    T_DO = 317,
    T_WHILE = 318,
    T_ENDWHILE = 319,
    T_FOR = 320,
    T_ENDFOR = 321,
    T_FOREACH = 322,
    T_ENDFOREACH = 323,
    T_DECLARE = 324,
    T_ENDDECLARE = 325,
    T_AS = 326,
    T_SWITCH = 327,
    T_ENDSWITCH = 328,
    T_CASE = 329,
    T_DEFAULT = 330,
    T_BREAK = 331,
    T_CONTINUE = 332,
    T_GOTO = 333,
    T_FUNCTION = 334,
    T_CONST = 335,
    T_RETURN = 336,
    T_TRY = 337,
    T_CATCH = 338,
    T_THROW = 339,
    T_USE = 340,
    T_INSTEADOF = 341,
    T_GLOBAL = 342,
    T_PUBLIC = 343,
    T_PROTECTED = 344,
    T_PRIVATE = 345,
    T_FINAL = 346,
    T_ABSTRACT = 347,
    T_STATIC = 348,
    T_VAR = 349,
    T_UNSET = 350,
    T_ISSET = 351,
    T_EMPTY = 352,
    T_HALT_COMPILER = 353,
    T_CLASS = 354,
    T_TRAIT = 355,
    T_INTERFACE = 356,
    T_EXTENDS = 357,
    T_IMPLEMENTS = 358,
    T_OBJECT_OPERATOR = 359,
    T_DOUBLE_ARROW = 360,
    T_LIST = 361,
    T_ARRAY = 362,
    T_CALLABLE = 363,
    T_CLASS_C = 364,
    T_TRAIT_C = 365,
    T_METHOD_C = 366,
    T_FUNC_C = 367,
    T_LINE = 368,
    T_FILE = 369,
    T_COMMENT = 370,
    T_DOC_COMMENT = 371,
    T_OPEN_TAG = 372,
    T_OPEN_TAG_WITH_ECHO = 373,
    T_CLOSE_TAG = 374,
    T_WHITESPACE = 375,
    T_START_HEREDOC = 376,
    T_END_HEREDOC = 377,
    T_DOLLAR_OPEN_CURLY_BRACES = 378,
    T_CURLY_OPEN = 379,
    T_PAAMAYIM_NEKUDOTAYIM = 380,
    T_NAMESPACE = 381,
    T_NS_C = 382,
    T_DIR = 383,
    T_NS_SEPARATOR = 384
} ;
typedef int YYSTYPE;
struct rpcent {
   char *r_name ;
   char **r_aliases ;
   int r_number ;
};
union sigval {
   int sival_int ;
   void *sival_ptr ;
};
typedef union sigval sigval_t;
struct __anonstruct__sigev_thread_102 {
   void (*_function)(sigval_t  ) ;
   void *_attribute ;
};
union __anonunion__sigev_un_101 {
   int _pad[64U / sizeof(int ) - 3U] ;
   __pid_t _tid ;
   struct __anonstruct__sigev_thread_102 _sigev_thread ;
};
struct sigevent {
   sigval_t sigev_value ;
   int sigev_signo ;
   int sigev_notify ;
   union __anonunion__sigev_un_101 _sigev_un ;
};
typedef struct sigevent sigevent_t;
enum __anonenum_103 {
    SIGEV_SIGNAL = 0,
    SIGEV_NONE = 1,
    SIGEV_THREAD = 2,
    SIGEV_THREAD_ID = 4
} ;
struct netent {
   char *n_name ;
   char **n_aliases ;
   int n_addrtype ;
   uint32_t n_net ;
};
struct hostent {
   char *h_name ;
   char **h_aliases ;
   int h_addrtype ;
   int h_length ;
   char **h_addr_list ;
};
struct servent {
   char *s_name ;
   char **s_aliases ;
   int s_port ;
   char *s_proto ;
};
struct protoent {
   char *p_name ;
   char **p_aliases ;
   int p_proto ;
};
struct addrinfo {
   int ai_flags ;
   int ai_family ;
   int ai_socktype ;
   int ai_protocol ;
   socklen_t ai_addrlen ;
   struct sockaddr *ai_addr ;
   char *ai_canonname ;
   struct addrinfo *ai_next ;
};
struct gaicb {
   char const   *ar_name ;
   char const   *ar_service ;
   struct addrinfo  const  *ar_request ;
   struct addrinfo *ar_result ;
   int __return ;
   int __unused[5] ;
};
enum __anonenum_104 {
    __LC_CTYPE = 0,
    __LC_NUMERIC = 1,
    __LC_TIME = 2,
    __LC_COLLATE = 3,
    __LC_MONETARY = 4,
    __LC_MESSAGES = 5,
    __LC_ALL = 6,
    __LC_PAPER = 7,
    __LC_NAME = 8,
    __LC_ADDRESS = 9,
    __LC_TELEPHONE = 10,
    __LC_MEASUREMENT = 11,
    __LC_IDENTIFICATION = 12
} ;
struct lconv {
   char *decimal_point ;
   char *thousands_sep ;
   char *grouping ;
   char *int_curr_symbol ;
   char *currency_symbol ;
   char *mon_decimal_point ;
   char *mon_thousands_sep ;
   char *mon_grouping ;
   char *positive_sign ;
   char *negative_sign ;
   char int_frac_digits ;
   char frac_digits ;
   char p_cs_precedes ;
   char p_sep_by_space ;
   char n_cs_precedes ;
   char n_sep_by_space ;
   char p_sign_posn ;
   char n_sign_posn ;
   char int_p_cs_precedes ;
   char int_p_sep_by_space ;
   char int_n_cs_precedes ;
   char int_n_sep_by_space ;
   char int_p_sign_posn ;
   char int_n_sign_posn ;
};
struct _user_tick_function_entry {
   zval **arguments ;
   int arg_count ;
   int calling ;
};
typedef struct _user_tick_function_entry user_tick_function_entry;
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))) ;
__inline extern  __attribute__((__nothrow__)) double atof(char const   *__nptr )  __attribute__((__pure__, __nonnull__(1))) ;
__inline extern double atof(char const   *__nptr ) 
{ double tmp ;

  {
  tmp = strtod((char const   */* __restrict  */)__nptr, (char **/* __restrict  */)((char **)((void *)0)));
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int atoi(char const   *__nptr )  __attribute__((__pure__, __nonnull__(1))) ;
__inline extern int atoi(char const   *__nptr ) 
{ long tmp ;

  {
  tmp = strtol((char const   */* __restrict  */)__nptr, (char **/* __restrict  */)((char **)((void *)0)), 10);
  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 ;

  {
  tmp = strtol((char const   */* __restrict  */)__nptr, (char **/* __restrict  */)((char **)((void *)0)), 10);
  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 ;

  {
  tmp = strtoll((char const   */* __restrict  */)__nptr, (char **/* __restrict  */)((char **)((void *)0)), 10);
  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 ) 
{ 

  {
  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 ) 
{ 

  {
  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 ) 
{ 

  {
  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 ;

  {
  __result = (size_t )0;
  while (1) {
    if ((int const   )*(__s + __result) != 0) {
      if ((int const   )*(__s + __result) != (int const   )__reject) {

      } else {
        break;
      }
    } else {
      break;
    }
    __result ++;
  }
  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 ;

  {
  __result = (size_t )0;
  while (1) {
    if ((int const   )*(__s + __result) != 0) {
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        if ((int const   )*(__s + __result) != (int const   )__reject2) {

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    __result ++;
  }
  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 ;

  {
  __result = (size_t )0;
  while (1) {
    if ((int const   )*(__s + __result) != 0) {
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          if ((int const   )*(__s + __result) != (int const   )__reject3) {

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    __result ++;
  }
  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 ;

  {
  __result = (size_t )0;
  while ((int const   )*(__s + __result) == (int const   )__accept) {
    __result ++;
  }
  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 ;

  {
  __result = (size_t )0;
  while (1) {
    if ((int const   )*(__s + __result) == (int const   )__accept1) {

    } else {
      if ((int const   )*(__s + __result) == (int const   )__accept2) {

      } else {
        break;
      }
    }
    __result ++;
  }
  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 ;

  {
  __result = (size_t )0;
  while (1) {
    if ((int const   )*(__s + __result) == (int const   )__accept1) {

    } else {
      if ((int const   )*(__s + __result) == (int const   )__accept2) {

      } else {
        if ((int const   )*(__s + __result) == (int const   )__accept3) {

        } else {
          break;
        }
      }
    }
    __result ++;
  }
  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 ;

  {
  while (1) {
    if ((int const   )*__s != 0) {
      if ((int const   )*__s != (int const   )__accept1) {
        if ((int const   )*__s != (int const   )__accept2) {

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    __s ++;
  }
  if ((int const   )*__s == 0) {
    tmp = (char *)((void *)0);
  } else {
    tmp = (char *)((unsigned int )__s);
  }
  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 ;

  {
  while (1) {
    if ((int const   )*__s != 0) {
      if ((int const   )*__s != (int const   )__accept1) {
        if ((int const   )*__s != (int const   )__accept2) {
          if ((int const   )*__s != (int const   )__accept3) {

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    __s ++;
  }
  if ((int const   )*__s == 0) {
    tmp = (char *)((void *)0);
  } else {
    tmp = (char *)((unsigned int )__s);
  }
  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 ;

  {
  if ((unsigned int )__s == (unsigned int )((void *)0)) {
    __s = *__nextp;
  } else {

  }
  while ((int )*__s == (int )__sep) {
    __s ++;
  }
  __result = (char *)((void *)0);
  if ((int )*__s != 0) {
    tmp = __s;
    __s ++;
    __result = tmp;
    while ((int )*__s != 0) {
      tmp___0 = __s;
      __s ++;
      if ((int )*tmp___0 == (int )__sep) {
        *(__s + -1) = (char )'\000';
        break;
      } else {

      }
    }
  } else {

  }
  *__nextp = __s;
  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 ;

  {
  __retval = *__s;
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    tmp___2 = __builtin_strchr(__retval, (int )__reject);
    tmp___0 = tmp___2;
    *__s = tmp___0;
    if ((unsigned int )tmp___0 != (unsigned int )((void *)0)) {
      tmp = *__s;
      (*__s) ++;
      *tmp = (char )'\000';
    } else {

    }
  } else {

  }
  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 ;

  {
  __retval = *__s;
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    __cp = __retval;
    while (1) {
      if ((int )*__cp == 0) {
        __cp = (char *)((void *)0);
        break;
      } else {

      }
      if ((int )*__cp == (int )__reject1) {
        tmp = __cp;
        __cp ++;
        *tmp = (char )'\000';
        break;
      } else {
        if ((int )*__cp == (int )__reject2) {
          tmp = __cp;
          __cp ++;
          *tmp = (char )'\000';
          break;
        } else {

        }
      }
      __cp ++;
    }
    *__s = __cp;
  } else {

  }
  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 ;

  {
  __retval = *__s;
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    __cp = __retval;
    while (1) {
      if ((int )*__cp == 0) {
        __cp = (char *)((void *)0);
        break;
      } else {

      }
      if ((int )*__cp == (int )__reject1) {
        tmp = __cp;
        __cp ++;
        *tmp = (char )'\000';
        break;
      } else {
        if ((int )*__cp == (int )__reject2) {
          tmp = __cp;
          __cp ++;
          *tmp = (char )'\000';
          break;
        } else {
          if ((int )*__cp == (int )__reject3) {
            tmp = __cp;
            __cp ++;
            *tmp = (char )'\000';
            break;
          } else {

          }
        }
      }
      __cp ++;
    }
    *__s = __cp;
  } else {

  }
  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 ;

  {
  __u.__f = __x;
  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 ;

  {
  __u.__d = __x;
  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 ;

  {
  __u.__l = __x;
  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 ;

  {
  if (__x == 0.0) {
    tmp___0 = 0.0;
  } else {
    if (__x > 0.0) {
      tmp = 1.0;
    } else {
      tmp = - 1.0;
    }
    tmp___0 = tmp;
  }
  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 ;

  {
  if ((double )__x == 0.0) {
    tmp___0 = 0.0;
  } else {
    if ((double )__x > 0.0) {
      tmp = 1.0;
    } else {
      tmp = - 1.0;
    }
    tmp___0 = tmp;
  }
  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 ;

  {
  if (__x == (long double )0.0) {
    tmp___0 = 0.0;
  } else {
    if (__x > (long double )0.0) {
      tmp = 1.0;
    } else {
      tmp = - 1.0;
    }
    tmp___0 = tmp;
  }
  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 ;

  {
  tmp = __builtin_atan2l(__y, __x);
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) double fabs(double __x )  __attribute__((__const__)) ;
__inline extern double fabs(double __x ) 
{ double tmp ;

  {
  tmp = __builtin_fabs(__x);
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) float fabsf(float __x )  __attribute__((__const__)) ;
__inline extern float fabsf(float __x ) 
{ float tmp ;

  {
  tmp = __builtin_fabsf(__x);
  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 ;

  {
  tmp = __builtin_fabsl(__x);
  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 ;

  {
  tmp = __builtin_fabsl(__x);
  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 ;

  {
  __n.__xld = __x;
  __n.__xi[2] = (__n.__xi[2] & 32768U) | 16383U;
  __n.__xi[1] = 0x80000000;
  __n.__xi[0] = 0U;
  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 ;

  {
  __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));
  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 ;

  {
  __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));
  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 ;

  {
  __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));
  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 ;

  {
  __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));
  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 ;

  {
  __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));
  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 ;

  {
  __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));
  return (__value);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintf(float __x ) ;
__inline extern long lrintf(float __x ) 
{ long __lrintres ;

  {
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrint(double __x ) ;
__inline extern long lrint(double __x ) 
{ long __lrintres ;

  {
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintl(long double __x ) ;
__inline extern long lrintl(long double __x ) 
{ long __lrintres ;

  {
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintf(float __x ) ;
__inline extern long long llrintf(float __x ) 
{ long long __llrintres ;

  {
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrint(double __x ) ;
__inline extern long long llrint(double __x ) 
{ long long __llrintres ;

  {
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintl(long double __x ) ;
__inline extern long long llrintl(long double __x ) 
{ long long __llrintres ;

  {
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) int __finite(double __x )  __attribute__((__const__)) ;
__inline extern int __finite(double __x ) 
{ union __anonunion_28 __constr_expr_0 ;

  {
  __constr_expr_0.__d = __x;
  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 fclose(FILE *__stream ) ;
extern int fflush(FILE *__stream ) ;
extern int fflush_unlocked(FILE *__stream ) ;
extern int fcloseall(void) ;
extern FILE *fopen(char const   * __restrict  __filename , char const   * __restrict  __modes ) ;
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 fprintf(FILE * __restrict  __stream , char const   * __restrict  __format  , ...) ;
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 ;

  {
  tmp = vfprintf((FILE */* __restrict  */)stdout, __fmt, __arg);
  return (tmp);
}
}
__inline extern int getchar(void) 
{ int tmp ;

  {
  tmp = _IO_getc(stdin);
  return (tmp);
}
}
__inline extern int fgetc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end), 0L);
  if (tmp___3) {
    tmp___0 = __uflow(__fp);
    tmp___2 = tmp___0;
  } else {
    tmp___1 = __fp->_IO_read_ptr;
    (__fp->_IO_read_ptr) ++;
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  return (tmp___2);
}
}
__inline extern int getc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end), 0L);
  if (tmp___3) {
    tmp___0 = __uflow(__fp);
    tmp___2 = tmp___0;
  } else {
    tmp___1 = __fp->_IO_read_ptr;
    (__fp->_IO_read_ptr) ++;
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  return (tmp___2);
}
}
__inline extern int getchar_unlocked(void) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  tmp___3 = __builtin_expect((long )((unsigned int )stdin->_IO_read_ptr >= (unsigned int )stdin->_IO_read_end), 0L);
  if (tmp___3) {
    tmp___0 = __uflow(stdin);
    tmp___2 = tmp___0;
  } else {
    tmp___1 = stdin->_IO_read_ptr;
    (stdin->_IO_read_ptr) ++;
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  return (tmp___2);
}
}
__inline extern int putchar(int __c ) 
{ int tmp ;

  {
  tmp = _IO_putc(__c, stdout);
  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 ;

  {
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end), 0L);
  if (tmp___4) {
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    tmp___3 = tmp___0;
  } else {
    tmp___1 = __stream->_IO_write_ptr;
    (__stream->_IO_write_ptr) ++;
    tmp___2 = (char )__c;
    *tmp___1 = tmp___2;
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  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 ;

  {
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end), 0L);
  if (tmp___4) {
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    tmp___3 = tmp___0;
  } else {
    tmp___1 = __stream->_IO_write_ptr;
    (__stream->_IO_write_ptr) ++;
    tmp___2 = (char )__c;
    *tmp___1 = tmp___2;
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  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 ;

  {
  tmp___4 = __builtin_expect((long )((unsigned int )stdout->_IO_write_ptr >= (unsigned int )stdout->_IO_write_end), 0L);
  if (tmp___4) {
    tmp___0 = __overflow(stdout, (int )((unsigned char )__c));
    tmp___3 = tmp___0;
  } else {
    tmp___1 = stdout->_IO_write_ptr;
    (stdout->_IO_write_ptr) ++;
    tmp___2 = (char )__c;
    *tmp___1 = tmp___2;
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  return (tmp___3);
}
}
__inline extern __ssize_t getline(char ** __restrict  __lineptr , size_t * __restrict  __n , FILE * __restrict  __stream ) 
{ __ssize_t tmp ;

  {
  tmp = __getdelim(__lineptr, __n, '\n', __stream);
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
__inline extern int feof_unlocked(FILE *__stream ) 
{ 

  {
  return ((__stream->_flags & 0x10) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) int ferror_unlocked(FILE *__stream ) ;
__inline extern int ferror_unlocked(FILE *__stream ) 
{ 

  {
  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 ;

  {
  tmp___0 = malloc(len);
  tmp = tmp___0;
  if (tmp) {
    return (tmp);
  } else {

  }
  fprintf((FILE */* __restrict  */)stderr, (char const   */* __restrict  */)"Out of memory\n");
  exit(1);
}
}
__inline static void *__zend_calloc(size_t nmemb , size_t len ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  tmp___0 = _safe_malloc(nmemb, len, 0U);
  tmp = (void *)tmp___0;
  memset(tmp, 0, nmemb * len);
  return (tmp);
}
}
__inline static void *__zend_realloc(void *p , size_t len ) 
{ 

  {
  p = realloc(p, len);
  if (p) {
    return (p);
  } else {

  }
  fprintf((FILE */* __restrict  */)stderr, (char const   */* __restrict  */)"Out of memory\n");
  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 ;

  {
  hash = (ulong )5381;
  while (nKeyLength >= 8U) {
    tmp = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp;
    tmp___0 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___0;
    tmp___1 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___1;
    tmp___2 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___2;
    tmp___3 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___3;
    tmp___4 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___4;
    tmp___5 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___5;
    tmp___6 = arKey;
    arKey ++;
    hash = ((hash << 5) + hash) + (ulong )*tmp___6;
    nKeyLength -= 8U;
  }
  switch ((int )nKeyLength) {
  case 7: 
  tmp___7 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___7;
  case 6: 
  tmp___8 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___8;
  case 5: 
  tmp___9 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___9;
  case 4: 
  tmp___10 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___10;
  case 3: 
  tmp___11 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___11;
  case 2: 
  tmp___12 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___12;
  case 1: 
  tmp___13 = arKey;
  arKey ++;
  hash = ((hash << 5) + hash) + (ulong )*tmp___13;
  break;
  case 0: 
  break;
  }
  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 ;

  {
  while (1) {
    while (1) {
      tmp = arKey;
      if ((int const   )*tmp == 45) {
        tmp ++;
      } else {

      }
      if ((int const   )*tmp >= 48) {
        if ((int const   )*tmp <= 57) {
          end = (arKey + nKeyLength) - 1;
          if ((int const   )*end != 0) {
            break;
          } else {
            if ((int const   )*tmp == 48) {
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                if (end - tmp == 10) {
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {

                  }
                } else {

                }
              }
            }
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          while (1) {
            tmp ++;
            if ((unsigned int )tmp != (unsigned int )end) {
              if ((int const   )*tmp >= 48) {
                if ((int const   )*tmp <= 57) {

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            if ((int const   )*arKey == 45) {
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {

              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              if (idx > 2147483647UL) {
                break;
              } else {

              }
            }
            tmp___0 = _zend_hash_index_update_or_next_insert(ht, idx, pData, nDataSize, pDest, 1);
            return ((int )tmp___0);
          } else {

          }
        } else {

        }
      } else {

      }
      break;
    }
    break;
  }
  tmp___1 = _zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, 1);
  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 ;

  {
  while (1) {
    while (1) {
      tmp = arKey;
      if ((int const   )*tmp == 45) {
        tmp ++;
      } else {

      }
      if ((int const   )*tmp >= 48) {
        if ((int const   )*tmp <= 57) {
          end = (arKey + nKeyLength) - 1;
          if ((int const   )*end != 0) {
            break;
          } else {
            if ((int const   )*tmp == 48) {
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                if (end - tmp == 10) {
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {

                  }
                } else {

                }
              }
            }
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          while (1) {
            tmp ++;
            if ((unsigned int )tmp != (unsigned int )end) {
              if ((int const   )*tmp >= 48) {
                if ((int const   )*tmp <= 57) {

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            if ((int const   )*arKey == 45) {
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {

              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              if (idx > 2147483647UL) {
                break;
              } else {

              }
            }
            tmp___0 = zend_hash_del_key_or_index(ht, (char const   *)((void *)0), 0U, idx, 1);
            return ((int )tmp___0);
          } else {

          }
        } else {

        }
      } else {

      }
      break;
    }
    break;
  }
  tmp___1 = zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0UL, 0);
  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 ;

  {
  while (1) {
    while (1) {
      tmp = arKey;
      if ((int const   )*tmp == 45) {
        tmp ++;
      } else {

      }
      if ((int const   )*tmp >= 48) {
        if ((int const   )*tmp <= 57) {
          end = (arKey + nKeyLength) - 1;
          if ((int const   )*end != 0) {
            break;
          } else {
            if ((int const   )*tmp == 48) {
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                if (end - tmp == 10) {
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {

                  }
                } else {

                }
              }
            }
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          while (1) {
            tmp ++;
            if ((unsigned int )tmp != (unsigned int )end) {
              if ((int const   )*tmp >= 48) {
                if ((int const   )*tmp <= 57) {

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            if ((int const   )*arKey == 45) {
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {

              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              if (idx > 2147483647UL) {
                break;
              } else {

              }
            }
            tmp___0 = zend_hash_index_find((HashTable const   *)ht, idx, pData);
            return ((int )tmp___0);
          } else {

          }
        } else {

        }
      } else {

      }
      break;
    }
    break;
  }
  tmp___1 = zend_hash_find((HashTable const   *)ht, arKey, nKeyLength, pData);
  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 ;

  {
  while (1) {
    while (1) {
      tmp = arKey;
      if ((int const   )*tmp == 45) {
        tmp ++;
      } else {

      }
      if ((int const   )*tmp >= 48) {
        if ((int const   )*tmp <= 57) {
          end = (arKey + nKeyLength) - 1;
          if ((int const   )*end != 0) {
            break;
          } else {
            if ((int const   )*tmp == 48) {
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                if (end - tmp == 10) {
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {

                  }
                } else {

                }
              }
            }
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          while (1) {
            tmp ++;
            if ((unsigned int )tmp != (unsigned int )end) {
              if ((int const   )*tmp >= 48) {
                if ((int const   )*tmp <= 57) {

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            if ((int const   )*arKey == 45) {
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {

              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              if (idx > 2147483647UL) {
                break;
              } else {

              }
            }
            tmp___0 = zend_hash_index_exists((HashTable const   *)ht, idx);
            return ((int )tmp___0);
          } else {

          }
        } else {

        }
      } else {

      }
      break;
    }
    break;
  }
  tmp___1 = zend_hash_exists((HashTable const   *)ht, arKey, nKeyLength);
  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 ;

  {
  while (1) {
    while (1) {
      tmp = arKey;
      if ((int const   )*tmp == 45) {
        tmp ++;
      } else {

      }
      if ((int const   )*tmp >= 48) {
        if ((int const   )*tmp <= 57) {
          end = (arKey + nKeyLength) - 1;
          if ((int const   )*end != 0) {
            break;
          } else {
            if ((int const   )*tmp == 48) {
              if (nKeyLength > 2U) {
                break;
              } else {
                goto _L;
              }
            } else {
              _L: /* CIL Label */ 
              if (end - tmp > 10) {
                break;
              } else {
                if (end - tmp == 10) {
                  if ((int const   )*tmp > 50) {
                    break;
                  } else {

                  }
                } else {

                }
              }
            }
          }
          idx = (unsigned long )((int const   )*tmp - 48);
          while (1) {
            tmp ++;
            if ((unsigned int )tmp != (unsigned int )end) {
              if ((int const   )*tmp >= 48) {
                if ((int const   )*tmp <= 57) {

                } else {
                  break;
                }
              } else {
                break;
              }
            } else {
              break;
            }
            idx = idx * 10UL + (ulong )((int const   )*tmp - 48);
          }
          if ((unsigned int )tmp == (unsigned int )end) {
            if ((int const   )*arKey == 45) {
              if (idx - 1UL > 2147483647UL) {
                break;
              } else {

              }
              idx = (unsigned long )(- ((long )idx));
            } else {
              if (idx > 2147483647UL) {
                break;
              } else {

              }
            }
            tmp___0 = zend_hash_update_current_key_ex(ht, 2, (char const   *)((void *)0), 0U, idx, mode, pos);
            return ((int )tmp___0);
          } else {

          }
        } else {

        }
      } else {

      }
      break;
    }
    break;
  }
  tmp___1 = zend_hash_update_current_key_ex(ht, 1, arKey, nKeyLength, 0UL, mode, pos);
  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 const   *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 const   *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 const   *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 const   *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 ) 
{ 

  {
  return (pz->refcount__gc);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_set_refcount_p)(zval *pz , zend_uint rc ) 
{ zend_uint tmp ;

  {
  tmp = rc;
  pz->refcount__gc = tmp;
  return (tmp);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_addref_p)(zval *pz ) 
{ 

  {
  (pz->refcount__gc) ++;
  return (pz->refcount__gc);
}
}
__inline static zend_uint ( __attribute__((__always_inline__)) zval_delref_p)(zval *pz ) 
{ 

  {
  (pz->refcount__gc) --;
  return (pz->refcount__gc);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_isref_p)(zval *pz ) 
{ 

  {
  return (pz->is_ref__gc);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_p)(zval *pz ) 
{ zend_uchar tmp ;

  {
  tmp = (unsigned char)1;
  pz->is_ref__gc = tmp;
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_unset_isref_p)(zval *pz ) 
{ zend_uchar tmp ;

  {
  tmp = (unsigned char)0;
  pz->is_ref__gc = tmp;
  return (tmp);
}
}
__inline static zend_bool ( __attribute__((__always_inline__)) zval_set_isref_to_p)(zval *pz , zend_bool isref ) 
{ zend_uchar tmp ;

  {
  tmp = isref;
  pz->is_ref__gc = tmp;
  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 __attribute__((__visibility__("default")))  (*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 const   *data ) ;
extern int __attribute__((__visibility__("default")))  zend_get_configuration_directive(char const   *name , uint name_length , zval *contents ) ;
extern zend_gc_globals __attribute__((__visibility__("default")))  gc_globals ;
extern int __attribute__((__visibility__("default")))  gc_collect_cycles(void) ;
extern void __attribute__((__visibility__("default")))  gc_zval_possible_root(zval *zv ) ;
extern void __attribute__((__visibility__("default")))  gc_zobj_possible_root(zval *zv ) ;
extern void __attribute__((__visibility__("default")))  gc_remove_zval_from_buffer(zval *zv ) ;
extern void __attribute__((__visibility__("default")))  gc_globals_ctor(void) ;
extern void __attribute__((__visibility__("default")))  gc_globals_dtor(void) ;
extern void __attribute__((__visibility__("default")))  gc_init(void) ;
extern void __attribute__((__visibility__("default")))  gc_reset(void) ;
__inline static void ( __attribute__((__always_inline__)) gc_zval_check_possible_root)(zval *z ) 
{ 

  {
  if ((int )z->type == 4) {
    gc_zval_possible_root(z);
  } else {
    if ((int )z->type == 5) {
      gc_zval_possible_root(z);
    } else {

    }
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) gc_remove_from_buffer)(gc_root_buffer *root ) 
{ 

  {
  (root->next)->prev = root->prev;
  (root->prev)->next = root->next;
  root->prev = gc_globals.unused;
  gc_globals.unused = root;
  return;
}
}
extern  __attribute__((__nothrow__)) int *__errno_location(void)  __attribute__((__const__)) ;
extern char *program_invocation_name ;
extern char *program_invocation_short_name ;
extern  __attribute__((__nothrow__, __noreturn__)) void __assert_fail(char const   *__assertion , char const   *__file , unsigned int __line , char const   *__function ) ;
extern  __attribute__((__nothrow__, __noreturn__)) void __assert_perror_fail(int __errnum , char const   *__file , unsigned int __line , char const   *__function ) ;
extern  __attribute__((__nothrow__, __noreturn__)) void __assert(char const   *__assertion , char const   *__file , int __line ) ;
extern void __attribute__((__visibility__("default")))  zend_freedtoa(char *s ) ;
extern char __attribute__((__visibility__("default")))  *zend_dtoa(double _d , int mode , int ndigits , int *decpt , int *sign , char **rve ) ;
extern double __attribute__((__visibility__("default")))  zend_strtod(char const   *s00 , char const   **se ) ;
extern double __attribute__((__visibility__("default")))  zend_hex_strtod(char const   *str , char const   **endptr ) ;
extern double __attribute__((__visibility__("default")))  zend_oct_strtod(char const   *str , char const   **endptr ) ;
extern double __attribute__((__visibility__("default")))  zend_bin_strtod(char const   *str , char const   **endptr ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_strtod(void) ;
extern int __attribute__((__visibility__("default")))  zend_shutdown_strtod(void) ;
extern int __attribute__((__visibility__("default")))  add_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  sub_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  mul_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  div_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  mod_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  boolean_xor_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  boolean_not_function(zval *result , zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_not_function(zval *result , zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_or_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_and_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  bitwise_xor_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  shift_left_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  shift_right_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  concat_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_equal_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_identical_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_not_identical_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_not_equal_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_smaller_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  is_smaller_or_equal_function(zval *result , zval *op1 , zval *op2 ) ;
extern zend_bool __attribute__((__visibility__("default")))  instanceof_function_ex(zend_class_entry const   *instance_ce , zend_class_entry const   *ce , zend_bool interfaces_only ) ;
extern zend_bool __attribute__((__visibility__("default")))  instanceof_function(zend_class_entry const   *instance_ce , zend_class_entry const   *ce ) ;
__inline static long ( __attribute__((__always_inline__)) zend_dval_to_lval)(double d ) 
{ 

  {
  if (d > (double )2147483647L) {
    return ((long )((unsigned long )((long long )d)));
  } else {
    if (d < (double )(-0x7FFFFFFF-1)) {
      return ((long )((unsigned long )((long long )d)));
    } else {

    }
  }
  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 ;

  {
  base = 10;
  digits = 0;
  dp_or_e = 0;
  if (! length) {
    return ((unsigned char)0);
  } else {

  }
  while (1) {
    if ((int const   )*str == 32) {

    } else {
      if ((int const   )*str == 9) {

      } else {
        if ((int const   )*str == 10) {

        } else {
          if ((int const   )*str == 13) {

          } else {
            if ((int const   )*str == 11) {

            } else {
              if ((int const   )*str == 12) {

              } else {
                break;
              }
            }
          }
        }
      }
    }
    str ++;
    length --;
  }
  ptr = str;
  if ((int const   )*ptr == 45) {
    ptr ++;
  } else {
    if ((int const   )*ptr == 43) {
      ptr ++;
    } else {

    }
  }
  if ((int const   )*ptr >= 48) {
    if ((int const   )*ptr <= 57) {
      if (length > 2) {
        if ((int const   )*str == 48) {
          if ((int const   )*(str + 1) == 120) {
            base = 16;
            ptr += 2;
          } else {
            if ((int const   )*(str + 1) == 88) {
              base = 16;
              ptr += 2;
            } else {

            }
          }
        } else {

        }
      } else {

      }
      while ((int const   )*ptr == 48) {
        ptr ++;
      }
      type = (unsigned char)1;
      while (1) {
        if (digits >= 11) {
          if (dval) {
            break;
          } else {
            if (allow_errors == 1) {
              break;
            } else {

            }
          }
        } else {

        }
        check_digits: 
        if ((int const   )*ptr >= 48) {
          if ((int const   )*ptr <= 57) {
            goto __Cont;
          } else {
            goto _L___3;
          }
        } else {
          _L___3: /* CIL Label */ 
          if (base == 16) {
            if ((int const   )*ptr >= 65) {
              if ((int const   )*ptr <= 70) {
                goto __Cont;
              } else {
                goto _L___2;
              }
            } else {
              _L___2: /* CIL Label */ 
              if ((int const   )*ptr >= 97) {
                if ((int const   )*ptr <= 102) {
                  goto __Cont;
                } else {
                  goto _L___1;
                }
              } else {
                goto _L___1;
              }
            }
          } else {
            _L___1: /* CIL Label */ 
            if (base == 10) {
              if ((int const   )*ptr == 46) {
                if (dp_or_e < 1) {
                  goto process_double;
                } else {
                  goto _L___0;
                }
              } else {
                _L___0: /* CIL Label */ 
                if ((int const   )*ptr == 101) {
                  goto _L;
                } else {
                  if ((int const   )*ptr == 69) {
                    _L: /* CIL Label */ 
                    if (dp_or_e < 2) {
                      e = ptr + 1;
                      if ((int const   )*e == 45) {
                        tmp = e;
                        e ++;
                        ptr = tmp;
                      } else {
                        if ((int const   )*e == 43) {
                          tmp = e;
                          e ++;
                          ptr = tmp;
                        } else {

                        }
                      }
                      if ((int const   )*e >= 48) {
                        if ((int const   )*e <= 57) {
                          goto process_double;
                        } else {

                        }
                      } else {

                      }
                    } else {

                    }
                  } else {

                  }
                }
              }
            } else {

            }
          }
        }
        break;
        __Cont: /* CIL Label */ 
        digits ++;
        ptr ++;
      }
      if (base == 10) {
        if (digits >= 11) {
          dp_or_e = -1;
          goto process_double;
        } else {

        }
      } else {
        if (digits < 8) {

        } else {
          if (digits == 8) {
            if ((int const   )*(ptr + - digits) <= 55) {

            } else {
              goto _L___4;
            }
          } else {
            _L___4: /* CIL Label */ 
            if (dval) {
              tmp___0 = zend_hex_strtod(str, & ptr);
              local_dval = (double )tmp___0;
            } else {

            }
            type = (unsigned char)2;
          }
        }
      }
    } else {
      goto _L___5;
    }
  } else {
    _L___5: /* CIL Label */ 
    if ((int const   )*ptr == 46) {
      if ((int const   )*(ptr + 1) >= 48) {
        if ((int const   )*(ptr + 1) <= 57) {
          process_double: 
          type = (unsigned char)2;
          if (dval) {
            tmp___1 = zend_strtod(str, & ptr);
            local_dval = (double )tmp___1;
          } else {
            if (allow_errors != 1) {
              if (dp_or_e != -1) {
                tmp___3 = ptr;
                ptr ++;
                if ((int const   )*tmp___3 == 46) {
                  dp_or_e = 1;
                } else {
                  dp_or_e = 2;
                }
                goto check_digits;
              } else {

              }
            } else {

            }
          }
        } else {
          return ((unsigned char)0);
        }
      } else {
        return ((unsigned char)0);
      }
    } else {
      return ((unsigned char)0);
    }
  }
  if ((unsigned int )ptr != (unsigned int )(str + length)) {
    if (! allow_errors) {
      return ((unsigned char)0);
    } else {

    }
    if (allow_errors == -1) {
      zend_error(1 << 3L, "A non well formed numeric value encountered");
    } else {

    }
  } else {

  }
  if ((int )type == 1) {
    if (digits == 10) {
      if (0) {
        __s1_len = strlen(ptr + - digits);
        __s2_len = strlen(long_min_digits);
        if (! ((unsigned int )((void const   *)((ptr + - digits) + 1)) - (unsigned int )((void const   *)(ptr + - digits)) == 1U)) {
          goto _L___7;
        } else {
          if (__s1_len >= 4U) {
            _L___7: /* CIL Label */ 
            if (! ((unsigned int )((void const   *)(long_min_digits + 1)) - (unsigned int )((void const   *)(long_min_digits)) == 1U)) {
              tmp___10 = 1;
            } else {
              if (__s2_len >= 4U) {
                tmp___10 = 1;
              } else {
                tmp___10 = 0;
              }
            }
          } else {
            tmp___10 = 0;
          }
        }
        if (tmp___10) {
          tmp___5 = __builtin_strcmp(ptr + - digits, long_min_digits);
          tmp___9 = tmp___5;
        } else {
          tmp___8 = __builtin_strcmp(ptr + - digits, long_min_digits);
          tmp___9 = tmp___8;
        }
      } else {
        tmp___8 = __builtin_strcmp(ptr + - digits, long_min_digits);
        tmp___9 = tmp___8;
      }
      cmp = tmp___9;
      if (cmp < 0) {

      } else {
        if (cmp == 0) {
          if ((int const   )*str == 45) {

          } else {
            goto _L___8;
          }
        } else {
          _L___8: /* CIL Label */ 
          if (dval) {
            tmp___11 = zend_strtod(str, (char const   **)((void *)0));
            *dval = (double )tmp___11;
          } else {

          }
          return ((unsigned char)2);
        }
      }
    } else {

    }
    if (lval) {
      *lval = strtol((char const   */* __restrict  */)str, (char **/* __restrict  */)((void *)0), base);
    } else {

    }
    return ((unsigned char)1);
  } else {
    if (dval) {
      *dval = local_dval;
    } else {

    }
    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 ;

  {
  p = haystack;
  ne = *(needle + (needle_len - 1));
  if (needle_len == 1) {
    tmp = memchr((void const   *)p, (int )*needle, (unsigned int )(end - p));
    return ((char *)tmp);
  } else {

  }
  if (needle_len > end - haystack) {
    return ((char *)((void *)0));
  } else {

  }
  end -= needle_len;
  while ((unsigned int )p <= (unsigned int )end) {
    tmp___1 = memchr((void const   *)p, (int )*needle, (unsigned int )((end - p) + 1));
    p = (char *)tmp___1;
    if (p) {
      if ((int )ne == (int )*(p + (needle_len - 1))) {
        tmp___0 = memcmp((void const   *)needle, (void const   *)p, (unsigned int )(needle_len - 1));
        if (tmp___0) {

        } else {
          return (p);
        }
      } else {

      }
    } else {

    }
    if ((unsigned int )p == (unsigned int )((void *)0)) {
      return ((char *)((void *)0));
    } else {

    }
    p ++;
  }
  return ((char *)((void *)0));
}
}
__inline static void const   *zend_memrchr(void const   *s , int c , size_t n ) 
{ register unsigned char const   *e ;

  {
  if (n <= 0U) {
    return ((void const   *)((void *)0));
  } else {

  }
  e = ((unsigned char const   *)s + n) - 1;
  while ((unsigned int )e >= (unsigned int )((unsigned char const   *)s)) {
    if ((int const   )*e == (int const   )((unsigned char const   )c)) {
      return ((void const   *)e);
    } else {

    }
    e --;
  }
  return ((void const   *)((void *)0));
}
}
extern int __attribute__((__visibility__("default")))  increment_function(zval *op1 ) ;
extern int __attribute__((__visibility__("default")))  decrement_function(zval *op2 ) ;
extern void __attribute__((__visibility__("default")))  convert_scalar_to_number(zval *op ) ;
extern void __attribute__((__visibility__("default")))  _convert_to_string(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_long(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_double(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_long_base(zval *op , int base ) ;
extern void __attribute__((__visibility__("default")))  convert_to_null(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_boolean(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_array(zval *op ) ;
extern void __attribute__((__visibility__("default")))  convert_to_object(zval *op ) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_long_ex(int argc  , ...) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_double_ex(int argc  , ...) ;
extern void __attribute__((__visibility__("default")))  multi_convert_to_string_ex(int argc  , ...) ;
extern int __attribute__((__visibility__("default")))  add_char_to_string(zval *result , zval const   *op1 , zval const   *op2 ) ;
extern int __attribute__((__visibility__("default")))  add_string_to_string(zval *result , zval const   *op1 , zval const   *op2 ) ;
extern double __attribute__((__visibility__("default")))  zend_string_to_double(char const   *number , zend_uint length ) ;
extern int __attribute__((__visibility__("default")))  zval_is_true(zval *op ) ;
extern int __attribute__((__visibility__("default")))  compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  numeric_compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_compare_function_ex(zval *result , zval *op1 , zval *op2 , zend_bool case_insensitive ) ;
extern int __attribute__((__visibility__("default")))  string_compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_case_compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_locale_compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern void __attribute__((__visibility__("default")))  zend_str_tolower(char *str , unsigned int length ) ;
extern char __attribute__((__visibility__("default")))  *zend_str_tolower_copy(char *dest , char const   *source , unsigned int length ) ;
extern char __attribute__((__visibility__("default")))  *zend_str_tolower_dup(char const   *source , unsigned int length ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strcmp(zval *s1 , zval *s2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strncmp(zval *s1 , zval *s2 , zval *s3 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strcasecmp(zval *s1 , zval *s2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_zval_strncasecmp(zval *s1 , zval *s2 , zval *s3 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strcmp(char const   *s1 , uint len1 , char const   *s2 , uint len2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strncmp(char const   *s1 , uint len1 , char const   *s2 , uint len2 , uint length ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strcasecmp(char const   *s1 , uint len1 , char const   *s2 , uint len2 ) ;
extern int __attribute__((__visibility__("default")))  zend_binary_strncasecmp(char const   *s1 , uint len1 , char const   *s2 , uint len2 , uint length ) ;
extern void __attribute__((__visibility__("default")))  zendi_smart_strcmp(zval *result , zval *s1 , zval *s2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_symbol_tables(zval *result , HashTable *ht1 , HashTable *ht2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_arrays(zval *result , zval *a1 , zval *a2 ) ;
extern void __attribute__((__visibility__("default")))  zend_compare_objects(zval *result , zval *o1 , zval *o2 ) ;
extern int __attribute__((__visibility__("default")))  zend_atoi(char const   *str , int str_len ) ;
extern long __attribute__((__visibility__("default")))  zend_atol(char const   *str , int str_len ) ;
extern void __attribute__((__visibility__("default")))  zend_locale_sprintf_double(zval *op ) ;
__inline static int ( __attribute__((__always_inline__)) fast_increment_function)(zval *op1 ) 
{ long tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  tmp = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp) {
    __asm__  ("incl (%0)\n\t"
              "jno  0f\n\t"
              "movl $0x0, (%0)\n\t"
              "movl $0x41e00000, 0x4(%0)\n\t"
              "movb $0x2,0xc(%0)\n"
              "0:": : "r" (op1));
    return (0);
  } else {

  }
  tmp___0 = increment_function(op1);
  return ((int )tmp___0);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_decrement_function)(zval *op1 ) 
{ long tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  tmp = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp) {
    __asm__  ("decl (%0)\n\t"
              "jno  0f\n\t"
              "movl $0x00200000, (%0)\n\t"
              "movl $0xc1e00000, 0x4(%0)\n\t"
              "movb $0x2,0xc(%0)\n"
              "0:": : "r" (op1));
    return (0);
  } else {

  }
  tmp___0 = decrement_function(op1);
  return ((int )tmp___0);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_add_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      __asm__  ("movl\t(%1), %%eax\n\t"
                "addl   (%2), %%eax\n\t"
                "jo     0f\n\t"
                "movl   %%eax, (%0)\n\t"
                "movb   $0x1,0xc(%0)\n\t"
                "jmp    1f\n"
                "0:\n\t"
                "fildl\t(%1)\n\t"
                "fildl\t(%2)\n\t"
                "faddp\t%%st, %%st(1)\n\t"
                "movb   $0x2,0xc(%0)\n\t"
                "fstpl\t(%0)\n"
                "1:": : "r" (result), "r" (op1), "r" (op2): "eax");
      return (0);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        result->value.dval = (double )op1->value.lval + op2->value.dval;
        result->type = (unsigned char)2;
        return (0);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        result->value.dval = op1->value.dval + op2->value.dval;
        result->type = (unsigned char)2;
        return (0);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          result->value.dval = op1->value.dval + (double )op2->value.lval;
          result->type = (unsigned char)2;
          return (0);
        } else {

        }
      }
    } else {

    }
  }
  tmp___5 = add_function(result, op1, op2);
  return ((int )tmp___5);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_sub_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      __asm__  ("movl\t(%1), %%eax\n\t"
                "subl   (%2), %%eax\n\t"
                "jo     0f\n\t"
                "movl   %%eax, (%0)\n\t"
                "movb   $0x1,0xc(%0)\n\t"
                "jmp    1f\n"
                "0:\n\t"
                "fildl\t(%2)\n\t"
                "fildl\t(%1)\n\t"
                "fsubp\t%%st, %%st(1)\n\t"
                "movb   $0x2,0xc(%0)\n\t"
                "fstpl\t(%0)\n"
                "1:": : "r" (result), "r" (op1), "r" (op2): "eax");
      return (0);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        result->value.dval = (double )op1->value.lval - op2->value.dval;
        result->type = (unsigned char)2;
        return (0);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        result->value.dval = op1->value.dval - op2->value.dval;
        result->type = (unsigned char)2;
        return (0);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          result->value.dval = op1->value.dval - (double )op2->value.lval;
          result->type = (unsigned char)2;
          return (0);
        } else {

        }
      }
    } else {

    }
  }
  tmp___5 = sub_function(result, op1, op2);
  return ((int )tmp___5);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_mul_function)(zval *result , zval *op1 , zval *op2 ) 
{ long overflow ;
  long __tmpvar ;
  long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      while (1) {
        __asm__  ("imul %3,%0\n"
                  "adc $0,%1": "=r" (__tmpvar), "=r" (overflow): "0" (op1->value.lval), "r" (op2->value.lval), "1" (0));
        if (overflow) {
          result->value.dval = (double )op1->value.lval * (double )op2->value.lval;
        } else {
          result->value.lval = __tmpvar;
        }
        break;
      }
      if (overflow) {
        result->type = (unsigned char)2;
      } else {
        result->type = (unsigned char)1;
      }
      return (0);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        result->value.dval = (double )op1->value.lval * op2->value.dval;
        result->type = (unsigned char)2;
        return (0);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        result->value.dval = op1->value.dval * op2->value.dval;
        result->type = (unsigned char)2;
        return (0);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          result->value.dval = op1->value.dval * (double )op2->value.lval;
          result->type = (unsigned char)2;
          return (0);
        } else {

        }
      }
    } else {

    }
  }
  tmp___5 = mul_function(result, op1, op2);
  return ((int )tmp___5);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_div_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  int tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;
  long tmp___5 ;
  long tmp___6 ;
  long tmp___7 ;
  long tmp___8 ;
  long tmp___9 ;
  long tmp___10 ;
  long tmp___11 ;
  int __attribute__((__visibility__("default")))  tmp___12 ;

  {
  tmp___11 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___11) {
    goto _L;
  } else {
    _L: /* CIL Label */ 
    tmp___10 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___10) {

    } else {

    }
  }
  tmp___12 = div_function(result, op1, op2);
  return ((int )tmp___12);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_mod_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;

  {
  tmp___2 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___2) {
    tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___1) {
      tmp___0 = __builtin_expect((long )(op2->value.lval == 0L), 0L);
      if (tmp___0) {
        zend_error(1 << 1L, "Division by zero");
        result->value.lval = 0L;
        result->type = (unsigned char)3;
        return (-1);
      } else {
        tmp = __builtin_expect((long )(op2->value.lval == -1L), 0L);
        if (tmp) {
          result->value.lval = 0L;
          result->type = (unsigned char)1;
          return (0);
        } else {

        }
      }
      result->value.lval = op1->value.lval % op2->value.lval;
      result->type = (unsigned char)1;
      return (0);
    } else {

    }
  } else {

  }
  tmp___3 = mod_function(result, op1, op2);
  return ((int )tmp___3);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_equal_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      return (op1->value.lval == op2->value.lval);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        return ((double )op1->value.lval == op2->value.dval);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        return (op1->value.dval == op2->value.dval);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          return (op1->value.dval == (double )op2->value.lval);
        } else {

        }
      }
    } else {

    }
  }
  compare_function(result, op1, op2);
  return (result->value.lval == 0L);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_not_equal_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      return (op1->value.lval != op2->value.lval);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        return ((double )op1->value.lval != op2->value.dval);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        return (op1->value.dval != op2->value.dval);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          return (op1->value.dval != (double )op2->value.lval);
        } else {

        }
      }
    } else {

    }
  }
  compare_function(result, op1, op2);
  return (result->value.lval != 0L);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_is_smaller_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      return (op1->value.lval < op2->value.lval);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        return ((double )op1->value.lval < op2->value.dval);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        return (op1->value.dval < op2->value.dval);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          return (op1->value.dval < (double )op2->value.lval);
        } else {

        }
      }
    } else {

    }
  }
  compare_function(result, op1, op2);
  return (result->value.lval < 0L);
}
}
__inline static int ( __attribute__((__always_inline__)) fast_is_smaller_or_equal_function)(zval *result , zval *op1 , zval *op2 ) 
{ long tmp ;
  long tmp___0 ;
  long tmp___1 ;
  long tmp___2 ;
  long tmp___3 ;
  long tmp___4 ;

  {
  tmp___4 = __builtin_expect((long )((int )op1->type == 1), 1L);
  if (tmp___4) {
    tmp___0 = __builtin_expect((long )((int )op2->type == 1), 1L);
    if (tmp___0) {
      return (op1->value.lval <= op2->value.lval);
    } else {
      tmp = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp) {
        return ((double )op1->value.lval <= op2->value.dval);
      } else {

      }
    }
  } else {
    tmp___3 = __builtin_expect((long )((int )op1->type == 2), 1L);
    if (tmp___3) {
      tmp___2 = __builtin_expect((long )((int )op2->type == 2), 1L);
      if (tmp___2) {
        return (op1->value.dval <= op2->value.dval);
      } else {
        tmp___1 = __builtin_expect((long )((int )op2->type == 1), 1L);
        if (tmp___1) {
          return (op1->value.dval <= (double )op2->value.lval);
        } else {

        }
      }
    } else {

    }
  }
  compare_function(result, op1, op2);
  return (result->value.lval <= 0L);
}
}
extern void __attribute__((__visibility__("default")))  _zval_dtor_func(zval *zvalue ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_dtor)(zval *zvalue ) 
{ 

  {
  if ((int )zvalue->type <= 3) {
    return;
  } else {

  }
  _zval_dtor_func(zvalue);
  return;
}
}
extern void __attribute__((__visibility__("default")))  _zval_copy_ctor_func(zval *zvalue ) ;
__inline static void ( __attribute__((__always_inline__)) _zval_copy_ctor)(zval *zvalue ) 
{ 

  {
  if ((int )zvalue->type <= 3) {
    return;
  } else {

  }
  _zval_copy_ctor_func(zvalue);
  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 ;

  {
  if (stack->top + 3 > stack->max) {
    while (1) {
      stack->max += 64;
      if (stack->top + 3 > stack->max) {

      } else {
        break;
      }
    }
    if (stack->persistent) {
      tmp = __zend_realloc((void *)stack->elements, sizeof(void *) * (unsigned int )stack->max);
      tmp___1 = tmp;
    } else {
      tmp___0 = _erealloc((void *)stack->elements, sizeof(void *) * (unsigned int )stack->max, 0);
      tmp___1 = (void *)tmp___0;
    }
    stack->elements = (void **)tmp___1;
    stack->top_element = stack->elements + stack->top;
  } else {

  }
  stack->top += 3;
  tmp___2 = stack->top_element;
  (stack->top_element) ++;
  *tmp___2 = a;
  tmp___3 = stack->top_element;
  (stack->top_element) ++;
  *tmp___3 = b;
  tmp___4 = stack->top_element;
  (stack->top_element) ++;
  *tmp___4 = c;
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_push)(zend_ptr_stack *stack , void *a , void *b ) 
{ void *tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  void *tmp___1 ;
  void **tmp___2 ;
  void **tmp___3 ;

  {
  if (stack->top + 2 > stack->max) {
    while (1) {
      stack->max += 64;
      if (stack->top + 2 > stack->max) {

      } else {
        break;
      }
    }
    if (stack->persistent) {
      tmp = __zend_realloc((void *)stack->elements, sizeof(void *) * (unsigned int )stack->max);
      tmp___1 = tmp;
    } else {
      tmp___0 = _erealloc((void *)stack->elements, sizeof(void *) * (unsigned int )stack->max, 0);
      tmp___1 = (void *)tmp___0;
    }
    stack->elements = (void **)tmp___1;
    stack->top_element = stack->elements + stack->top;
  } else {

  }
  stack->top += 2;
  tmp___2 = stack->top_element;
  (stack->top_element) ++;
  *tmp___2 = a;
  tmp___3 = stack->top_element;
  (stack->top_element) ++;
  *tmp___3 = b;
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_3_pop)(zend_ptr_stack *stack , void **a , void **b , void **c ) 
{ 

  {
  (stack->top_element) --;
  *a = *(stack->top_element);
  (stack->top_element) --;
  *b = *(stack->top_element);
  (stack->top_element) --;
  *c = *(stack->top_element);
  stack->top -= 3;
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_ptr_stack_2_pop)(zend_ptr_stack *stack , void **a , void **b ) 
{ 

  {
  (stack->top_element) --;
  *a = *(stack->top_element);
  (stack->top_element) --;
  *b = *(stack->top_element);
  stack->top -= 2;
  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 ;

  {
  if (stack->top + 1 > stack->max) {
    while (1) {
      stack->max += 64;
      if (stack->top + 1 > stack->max) {

      } else {
        break;
      }
    }
    if (stack->persistent) {
      tmp = __zend_realloc((void *)stack->elements, sizeof(void *) * (unsigned int )stack->max);
      tmp___1 = tmp;
    } else {
      tmp___0 = _erealloc((void *)stack->elements, sizeof(void *) * (unsigned int )stack->max, 0);
      tmp___1 = (void *)tmp___0;
    }
    stack->elements = (void **)tmp___1;
    stack->top_element = stack->elements + stack->top;
  } else {

  }
  (stack->top) ++;
  tmp___2 = stack->top_element;
  (stack->top_element) ++;
  *tmp___2 = ptr;
  return;
}
}
__inline static void *( __attribute__((__always_inline__)) zend_ptr_stack_pop)(zend_ptr_stack *stack ) 
{ 

  {
  (stack->top) --;
  (stack->top_element) --;
  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 ) 
{ 

  {
  zend_objects_store_del_ref_by_handle_ex(handle, (zend_object_handlers const   *)((void *)0));
  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 const __attribute__((__visibility__("default")))  *zend_get_compiled_variable_name(zend_op_array const   *op_array , zend_uint var , int *name_len ) ;
extern void zend_do_binary_op(zend_uchar op , znode *result , znode const   *op1 , znode const   *op2 ) ;
extern void zend_do_unary_op(zend_uchar op , znode *result , znode const   *op1 ) ;
extern void zend_do_binary_assign_op(zend_uchar op , znode *result , znode const   *op1 , znode const   *op2 ) ;
extern void zend_do_assign(znode *result , znode *variable , znode *value ) ;
extern void zend_do_assign_ref(znode *result , znode const   *lvar , znode const   *rvar ) ;
extern void fetch_simple_variable(znode *result , znode *varname , int bp ) ;
extern void fetch_simple_variable_ex(znode *result , znode *varname , int bp , zend_uchar op ) ;
extern void zend_do_indirect_references(znode *result , znode const   *num_references , znode *variable ) ;
extern void zend_do_fetch_static_variable(znode *varname , znode const   *static_assignment , int fetch_type ) ;
extern void zend_do_fetch_global_variable(znode *varname , znode const   *static_assignment , int fetch_type ) ;
extern void fetch_array_begin(znode *result , znode *varname , znode *first_dim ) ;
extern void fetch_array_dim(znode *result , znode const   *parent , znode const   *dim ) ;
extern void fetch_string_offset(znode *result , znode const   *parent , znode const   *offset ) ;
extern void zend_do_fetch_static_member(znode *result , znode *class_znode ) ;
extern void zend_do_print(znode *result , znode const   *arg ) ;
extern void zend_do_echo(znode const   *arg ) ;
extern unary_op_type __attribute__((__visibility__("default")))  get_unary_op(int opcode ) ;
extern binary_op_type __attribute__((__visibility__("default")))  get_binary_op(int opcode ) ;
extern void zend_do_while_cond(znode const   *expr , znode *close_bracket_token ) ;
extern void zend_do_while_end(znode const   *while_token , znode const   *close_bracket_token ) ;
extern void zend_do_do_while_begin(void) ;
extern void zend_do_do_while_end(znode const   *do_token , znode const   *expr_open_bracket , znode const   *expr ) ;
extern void zend_do_if_cond(znode const   *cond , znode *closing_bracket_token ) ;
extern void zend_do_if_after_statement(znode const   *closing_bracket_token , unsigned char initialize ) ;
extern void zend_do_if_end(void) ;
extern void zend_do_for_cond(znode const   *expr , znode *second_semicolon_token ) ;
extern void zend_do_for_before_statement(znode const   *cond_start , znode const   *second_semicolon_token ) ;
extern void zend_do_for_end(znode const   *second_semicolon_token ) ;
extern void zend_do_pre_incdec(znode *result , znode const   *op1 , zend_uchar op ) ;
extern void zend_do_post_incdec(znode *result , znode const   *op1 , zend_uchar op ) ;
extern void zend_do_begin_variable_parse(void) ;
extern void zend_do_end_variable_parse(znode *variable , int type , int arg_offset ) ;
extern void zend_check_writable_variable(znode const   *variable ) ;
extern void zend_do_free(znode *op1 ) ;
extern void zend_do_add_string(znode *result , znode const   *op1 , znode *op2 ) ;
extern void zend_do_add_variable(znode *result , znode const   *op1 , znode const   *op2 ) ;
extern int zend_do_verify_access_types(znode const   *current_access_type , znode const   *new_modifier ) ;
extern void zend_do_begin_function_declaration(znode *function_token , znode *function_name , int is_method , int return_reference , znode *fn_flags_znode ) ;
extern void zend_do_end_function_declaration(znode const   *function_token ) ;
extern void zend_do_receive_arg(zend_uchar op , znode *varname , znode const   *offset , znode const   *initialization , znode *class_type , zend_bool pass_by_reference ) ;
extern int zend_do_begin_function_call(znode *function_name , zend_bool check_namespace ) ;
extern void zend_do_begin_method_call(znode *left_bracket ) ;
extern void zend_do_clone(znode *result , znode const   *expr ) ;
extern void zend_do_begin_dynamic_function_call(znode *function_name , int prefix_len ) ;
extern void zend_do_fetch_class(znode *result , znode *class_name ) ;
extern void zend_do_build_full_name(znode *result , znode *prefix , znode *name , int is_class_member ) ;
extern int zend_do_begin_class_member_function_call(znode *class_name , znode *method_name ) ;
extern void zend_do_end_function_call(znode *function_name , znode *result , znode const   *argument_list , int is_method , int is_dynamic_fcall ) ;
extern void zend_do_return(znode *expr , int do_end_vparse ) ;
extern void zend_do_handle_exception(void) ;
extern void zend_do_begin_lambda_function_declaration(znode *result , znode *function_token , int return_reference , int is_static ) ;
extern void zend_do_fetch_lexical_variable(znode *varname , zend_bool is_ref ) ;
extern void zend_do_try(znode *try_token ) ;
extern void zend_do_begin_catch(znode *try_token , znode *catch_class , znode *catch_var , znode *first_catch ) ;
extern void zend_do_end_catch(znode const   *try_token ) ;
extern void zend_do_throw(znode const   *expr ) ;
extern int __attribute__((__visibility__("default")))  do_bind_function(zend_op_array const   *op_array , zend_op *opline , HashTable *function_table , zend_bool compile_time ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *do_bind_class(zend_op_array const   *op_array , zend_op const   *opline , HashTable *class_table , zend_bool compile_time ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *do_bind_inherited_class(zend_op_array const   *op_array , zend_op const   *opline , HashTable *class_table , zend_class_entry *parent_ce , zend_bool compile_time ) ;
extern void __attribute__((__visibility__("default")))  zend_do_inherit_interfaces(zend_class_entry *ce , zend_class_entry const   *iface ) ;
extern void __attribute__((__visibility__("default")))  zend_do_implement_interface(zend_class_entry *ce , zend_class_entry *iface ) ;
extern void zend_do_implements_interface(znode *interface_znode ) ;
extern void zend_add_trait_precedence(znode *precedence_znode ) ;
extern void zend_add_trait_alias(znode *alias_znode ) ;
extern void zend_do_implements_trait(znode *interface_znode ) ;
extern void __attribute__((__visibility__("default")))  zend_do_implement_trait(zend_class_entry *ce , zend_class_entry *trait ) ;
extern void __attribute__((__visibility__("default")))  zend_do_bind_traits(zend_class_entry *ce ) ;
extern void zend_prepare_trait_precedence(znode *result , znode *method_reference , znode *trait_list ) ;
extern void zend_prepare_reference(znode *result , znode *class_name , znode *method_name ) ;
extern void zend_prepare_trait_alias(znode *result , znode *method_reference , znode *modifiers , znode *alias ) ;
extern void init_trait_alias_list(znode *result , znode const   *trait_alias ) ;
extern void add_trait_alias(znode *result , znode const   *trait_alias ) ;
extern void init_trait_alias(znode *result , znode const   *method_name , znode const   *alias , znode const   *modifiers ) ;
extern void __attribute__((__visibility__("default")))  zend_do_inheritance(zend_class_entry *ce , zend_class_entry *parent_ce ) ;
extern void zend_do_early_binding(void) ;
extern void __attribute__((__visibility__("default")))  zend_do_delayed_early_binding(zend_op_array const   *op_array ) ;
extern void zend_do_pass_param(znode *param , zend_uchar op , int offset ) ;
extern void zend_do_boolean_or_begin(znode *expr1 , znode *op_token ) ;
extern void zend_do_boolean_or_end(znode *result , znode const   *expr1 , znode const   *expr2 , znode *op_token ) ;
extern void zend_do_boolean_and_begin(znode *expr1 , znode *op_token ) ;
extern void zend_do_boolean_and_end(znode *result , znode const   *expr1 , znode const   *expr2 , znode const   *op_token ) ;
extern void zend_do_brk_cont(zend_uchar op , znode const   *expr ) ;
extern void zend_do_switch_cond(znode const   *cond ) ;
extern void zend_do_switch_end(znode const   *case_list ) ;
extern void zend_do_case_before_statement(znode const   *case_list , znode *case_token , znode const   *case_expr ) ;
extern void zend_do_case_after_statement(znode *result , znode const   *case_token ) ;
extern void zend_do_default_before_statement(znode const   *case_list , znode *default_token ) ;
extern void zend_do_begin_class_declaration(znode const   *class_token , znode *class_name , znode const   *parent_class_name ) ;
extern void zend_do_end_class_declaration(znode const   *class_token , znode const   *parent_token ) ;
extern void zend_do_declare_property(znode const   *var_name , znode const   *value , zend_uint access_type ) ;
extern void zend_do_declare_class_constant(znode *var_name , znode const   *value ) ;
extern void zend_do_fetch_property(znode *result , znode *object , znode const   *property ) ;
extern void zend_do_halt_compiler_register(void) ;
extern void zend_do_push_object(znode const   *object ) ;
extern void zend_do_pop_object(znode *object ) ;
extern void zend_do_begin_new_object(znode *new_token , znode *class_type ) ;
extern void zend_do_end_new_object(znode *result , znode const   *new_token , znode const   *argument_list ) ;
extern void zend_do_fetch_constant(znode *result , znode *constant_container , znode *constant_name , int mode , zend_bool check_namespace ) ;
extern void zend_do_shell_exec(znode *result , znode const   *cmd ) ;
extern void zend_do_init_array(znode *result , znode const   *expr , znode const   *offset , zend_bool is_ref ) ;
extern void zend_do_add_array_element(znode *result , znode const   *expr , znode const   *offset , zend_bool is_ref ) ;
extern void zend_do_add_static_array_element(znode *result , znode *offset , znode const   *expr ) ;
extern void zend_do_list_init(void) ;
extern void zend_do_list_end(znode *result , znode *expr ) ;
extern void zend_do_add_list_element(znode const   *element ) ;
extern void zend_do_new_list_begin(void) ;
extern void zend_do_new_list_end(void) ;
extern void zend_init_list(void *result , void *item ) ;
extern void zend_add_to_list(void *result , void *item ) ;
extern void zend_do_cast(znode *result , znode const   *expr , int type ) ;
extern void zend_do_include_or_eval(int type , znode *result , znode const   *op1 ) ;
extern void zend_do_unset(znode const   *variable ) ;
extern void zend_do_isset_or_isempty(int type , znode *result , znode *variable ) ;
extern void zend_do_instanceof(znode *result , znode const   *expr , znode const   *class_znode , int type ) ;
extern void zend_do_foreach_begin(znode *foreach_token , znode *open_brackets_token , znode *array , znode *as_token , int variable ) ;
extern void zend_do_foreach_cont(znode *foreach_token , znode const   *open_brackets_token , znode const   *as_token , znode *value , znode *key ) ;
extern void zend_do_foreach_end(znode const   *foreach_token , znode const   *as_token ) ;
extern void zend_do_declare_begin(void) ;
extern void zend_do_declare_stmt(znode *var , znode *val ) ;
extern void zend_do_declare_end(znode const   *declare_token ) ;
extern void zend_do_exit(znode *result , znode const   *message ) ;
extern void zend_do_begin_silence(znode *strudel_token ) ;
extern void zend_do_end_silence(znode const   *strudel_token ) ;
extern void zend_do_jmp_set(znode const   *value , znode *jmp_token , znode *colon_token ) ;
extern void zend_do_jmp_set_else(znode *result , znode const   *false_value , znode const   *jmp_token , znode const   *colon_token ) ;
extern void zend_do_begin_qm_op(znode const   *cond , znode *qm_token ) ;
extern void zend_do_qm_true(znode const   *true_value , znode *qm_token , znode *colon_token ) ;
extern void zend_do_qm_false(znode *result , znode const   *false_value , znode const   *qm_token , znode const   *colon_token ) ;
extern void zend_do_extended_info(void) ;
extern void zend_do_extended_fcall_begin(void) ;
extern void zend_do_extended_fcall_end(void) ;
extern void zend_do_ticks(void) ;
extern void zend_do_abstract_method(znode const   *function_name , znode *modifiers , znode const   *body ) ;
extern void zend_do_declare_constant(znode *name , znode *value ) ;
extern void zend_do_build_namespace_name(znode *result , znode *prefix , znode *name ) ;
extern void zend_do_begin_namespace(znode const   *name , zend_bool with_brackets ) ;
extern void zend_do_end_namespace(void) ;
extern void zend_verify_namespace(void) ;
extern void zend_do_use(znode *name , znode *new_name , int is_global ) ;
extern void zend_do_end_compilation(void) ;
extern void zend_do_label(znode *label ) ;
extern void zend_do_goto(znode const   *label ) ;
extern void zend_resolve_goto_label(zend_op_array *op_array , zend_op *opline , int pass2 ) ;
extern void zend_release_labels(void) ;
extern void __attribute__((__visibility__("default")))  function_add_ref(zend_function *function ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *compile_file(zend_file_handle *file_handle , int type ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *compile_string(zval *source_string , char *filename ) ;
extern zend_op_array __attribute__((__visibility__("default")))  *compile_filename(int type , zval *filename ) ;
extern int __attribute__((__visibility__("default")))  zend_execute_scripts(int type , zval **retval , int file_count  , ...) ;
extern int __attribute__((__visibility__("default")))  open_file_for_scanning(zend_file_handle *file_handle ) ;
extern void __attribute__((__visibility__("default")))  init_op_array(zend_op_array *op_array , zend_uchar type , int initial_ops_size ) ;
extern void __attribute__((__visibility__("default")))  destroy_op_array(zend_op_array *op_array ) ;
extern void __attribute__((__visibility__("default")))  zend_destroy_file_handle(zend_file_handle *file_handle ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_class_data(zend_class_entry **pce ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_user_class_data(zend_class_entry **pce ) ;
extern void __attribute__((__visibility__("default")))  zend_cleanup_internal_class_data(zend_class_entry *ce ) ;
extern void __attribute__((__visibility__("default")))  zend_cleanup_internal_classes(void) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_function_data(zend_function *function ) ;
extern int __attribute__((__visibility__("default")))  zend_cleanup_function_data_full(zend_function *function ) ;
extern void __attribute__((__visibility__("default")))  destroy_zend_function(zend_function *function ) ;
extern void __attribute__((__visibility__("default")))  zend_function_dtor(zend_function *function ) ;
extern void __attribute__((__visibility__("default")))  destroy_zend_class(zend_class_entry **pce ) ;
extern void zend_class_add_ref(zend_class_entry **ce ) ;
extern void __attribute__((__visibility__("default")))  zend_mangle_property_name(char **dest , int *dest_length , char const   *src1 , int src1_length , char const   *src2 , int src2_length , int internal ) ;
extern int __attribute__((__visibility__("default")))  zend_unmangle_property_name(char const   *mangled_property , int mangled_property_len , char const   **class_name , char const   **prop_name ) ;
extern zend_op *get_next_op(zend_op_array *op_array ) ;
extern void init_op(zend_op *op ) ;
extern int get_next_op_number(zend_op_array *op_array ) ;
extern int print_class(zend_class_entry *class_entry ) ;
extern void print_op_array(zend_op_array *op_array , int optimizations ) ;
extern int __attribute__((__visibility__("default")))  pass_two(zend_op_array *op_array ) ;
extern zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array ) ;
extern void zend_do_first_catch(znode *open_parentheses ) ;
extern void zend_initialize_try_catch_element(znode const   *try_token ) ;
extern void zend_do_mark_last_catch(znode const   *first_catch , znode const   *last_additional_catch ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_compiling(void) ;
extern char __attribute__((__visibility__("default")))  *zend_make_compiled_string_description(char const   *name ) ;
extern void __attribute__((__visibility__("default")))  zend_initialize_class_data(zend_class_entry *ce , zend_bool nullify_handlers ) ;
extern int zend_get_class_fetch_type(char const   *class_name , uint class_name_len ) ;
extern int __attribute__((__visibility__("default")))  zend_register_auto_global(char const   *name , uint name_len , zend_bool jit , zend_bool (*auto_global_callback)(char const   *name , uint name_len ) ) ;
extern void __attribute__((__visibility__("default")))  zend_activate_auto_globals(void) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_auto_global(char const   *name , uint name_len ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_auto_global_quick(char const   *name , uint name_len , ulong hashval ) ;
extern size_t __attribute__((__visibility__("default")))  zend_dirname(char *path , size_t len ) ;
extern int zendlex(znode *zendlval ) ;
extern int zend_add_literal(zend_op_array *op_array , zval const   *zv ) ;
extern HashTable __attribute__((__visibility__("default")))  module_registry ;
extern void module_destructor(zend_module_entry *module ) ;
extern int module_registry_cleanup(zend_module_entry *module ) ;
extern int module_registry_request_startup(zend_module_entry *module ) ;
extern int module_registry_unload_temp(zend_module_entry const   *module ) ;
extern 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 ) 
{ 

  {
  if ((unsigned int )p != (unsigned int )executor_globals.uninitialized_zval_ptr) {
    while (1) {
      if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)p)->u.buffered & 4294967292UL)) {
        gc_remove_zval_from_buffer(p);
      } else {

      }
      _efree((void *)p);
      break;
    }
  } else {

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

  {
  tmp___0 = zval_delref_p(zval_ptr);
  if (tmp___0) {
    tmp = zval_refcount_p(zval_ptr);
    if (tmp == 1U) {
      zval_unset_isref_p(zval_ptr);
    } else {

    }
    gc_zval_check_possible_root(zval_ptr);
  } else {
    if ((unsigned int )zval_ptr != (unsigned int )(& executor_globals.uninitialized_zval)) {
      if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)zval_ptr)->u.buffered & 4294967292UL)) {
        gc_remove_zval_from_buffer(zval_ptr);
      } else {

      }
      _zval_dtor(zval_ptr);
      _efree((void *)zval_ptr);
    } else {

    }
  }
  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) {
  case 0: 
  result = 0;
  break;
  case 1: 
  case 3: 
  case 7: 
  if (op->value.lval) {
    result = 1;
  } else {
    result = 0;
  }
  break;
  case 2: 
  if (op->value.dval) {
    result = 1;
  } else {
    result = 0;
  }
  break;
  case 6: 
  if (op->value.str.len == 0) {
    result = 0;
  } else {
    if (op->value.str.len == 1) {
      if ((int )*(op->value.str.val + 0) == 48) {
        result = 0;
      } else {
        result = 1;
      }
    } else {
      result = 1;
    }
  }
  break;
  case 4: 
  tmp___0 = zend_hash_num_elements((HashTable const   *)op->value.ht);
  if (tmp___0) {
    result = 1;
  } else {
    result = 0;
  }
  break;
  case 5: 
  if ((int )op->type == 5) {
    if ((unsigned int )(op->value.obj.handlers)->get_class_entry != (unsigned int )((void *)0)) {
      if ((op->value.obj.handlers)->cast_object) {
        tmp___2 = (*((op->value.obj.handlers)->cast_object))(op, & tmp___1, 3);
        if (tmp___2 == 0) {
          result = (int )tmp___1.value.lval;
          break;
        } else {

        }
      } else {
        if ((op->value.obj.handlers)->get) {
          tmp___4 = (*((op->value.obj.handlers)->get))(op);
          tmp___3 = tmp___4;
          if ((int )tmp___3->type != 5) {
            convert_to_boolean(tmp___3);
            result = (int )tmp___3->value.lval;
            _zval_ptr_dtor(& tmp___3);
            break;
          } else {

          }
        } else {

        }
      }
    } else {

    }
  } else {

  }
  result = 1;
  break;
  default: 
  result = 0;
  break;
  }
  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 ;

  {
  tmp = _emalloc((((sizeof(*page) + 4U) - 1U) & 4294967292U) + sizeof(void *) * (unsigned int )count);
  page = (struct _zend_vm_stack *)tmp;
  page->top = (void **)((char *)page + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U));
  page->end = page->top + count;
  page->prev = (struct _zend_vm_stack *)((void *)0);
  return (page);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_init)(void) 
{ 

  {
  executor_globals.argument_stack = zend_vm_stack_new_page(16368);
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_destroy)(void) 
{ zend_vm_stack stack ;
  zend_vm_stack p ;

  {
  stack = executor_globals.argument_stack;
  while ((unsigned int )stack != (unsigned int )((void *)0)) {
    p = stack->prev;
    _efree((void *)stack);
    stack = p;
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_extend)(int count ) 
{ zend_vm_stack p ;
  int tmp ;
  zend_vm_stack tmp___0 ;

  {
  if (count >= 16368) {
    tmp = count;
  } else {
    tmp = 16368;
  }
  tmp___0 = zend_vm_stack_new_page(tmp);
  p = tmp___0;
  p->prev = executor_globals.argument_stack;
  executor_globals.argument_stack = p;
  return;
}
}
__inline static void **( __attribute__((__always_inline__)) zend_vm_stack_top)(void) 
{ 

  {
  return ((executor_globals.argument_stack)->top);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push)(void *ptr ) 
{ long tmp ;
  void **tmp___0 ;

  {
  while (1) {
    tmp = __builtin_expect((long )(1 > (executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top), 0L);
    if (tmp) {
      zend_vm_stack_extend(1);
    } else {

    }
    break;
  }
  tmp___0 = (executor_globals.argument_stack)->top;
  ((executor_globals.argument_stack)->top) ++;
  *tmp___0 = ptr;
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_push_nocheck)(void *ptr ) 
{ void **tmp ;

  {
  tmp = (executor_globals.argument_stack)->top;
  ((executor_globals.argument_stack)->top) ++;
  *tmp = ptr;
  return;
}
}
__inline static void *( __attribute__((__always_inline__)) zend_vm_stack_pop)(void) 
{ void *el ;
  zend_vm_stack p ;
  long tmp ;

  {
  ((executor_globals.argument_stack)->top) --;
  el = *((executor_globals.argument_stack)->top);
  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);
  if (tmp) {
    p = executor_globals.argument_stack;
    executor_globals.argument_stack = p->prev;
    _efree((void *)p);
  } else {

  }
  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 ;

  {
  size = (size + (sizeof(void *) - 1U)) / sizeof(void *);
  if (4U > sizeof(void *)) {
    extra = (int )((4UL - ((unsigned long )(executor_globals.argument_stack)->top & 3UL)) / (unsigned long )sizeof(void *));
    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);
    if (tmp) {
      zend_vm_stack_extend((int )size);
    } else {
      old_top = (executor_globals.argument_stack)->top;
      (executor_globals.argument_stack)->top += extra;
      *((executor_globals.argument_stack)->top) = (void *)old_top;
      (executor_globals.argument_stack)->top += (((sizeof(void *) + 4U) - 1U) & 4294967292U) / sizeof(void *);
    }
  } else {
    while (1) {
      tmp___0 = __builtin_expect((long )((int )size > (executor_globals.argument_stack)->end - (executor_globals.argument_stack)->top), 0L);
      if (tmp___0) {
        zend_vm_stack_extend((int )size);
      } else {

      }
      break;
    }
  }
  ret = (void *)(executor_globals.argument_stack)->top;
  (executor_globals.argument_stack)->top += size;
  return (ret);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free_int)(void *ptr ) 
{ zend_vm_stack p ;
  long tmp ;

  {
  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);
  if (tmp) {
    p = executor_globals.argument_stack;
    executor_globals.argument_stack = p->prev;
    _efree((void *)p);
  } else {
    (executor_globals.argument_stack)->top = (void **)ptr;
  }
  return;
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_free)(void *ptr ) 
{ zend_vm_stack p ;
  long tmp ;

  {
  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);
  if (tmp) {
    p = executor_globals.argument_stack;
    executor_globals.argument_stack = p->prev;
    _efree((void *)p);
  } else {
    if (4U > sizeof(void *)) {
      ptr = (void *)((char *)ptr - (((sizeof(void *) + 4U) - 1U) & 4294967292U));
      (executor_globals.argument_stack)->top = *((void ***)ptr);
    } else {
      (executor_globals.argument_stack)->top = (void **)ptr;
    }
  }
  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 ;

  {
  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);
  if (tmp___2) {
    goto _L;
  } else {
    tmp___3 = __builtin_expect((long )((unsigned int )(executor_globals.argument_stack)->top == (unsigned int )(executor_globals.argument_stack)->end), 0L);
    if (tmp___3) {
      _L: /* CIL Label */ 
      p = executor_globals.argument_stack;
      zend_vm_stack_extend(count + 1);
      (executor_globals.argument_stack)->top += count;
      *((executor_globals.argument_stack)->top) = (void *)((unsigned long )count);
      while (1) {
        tmp___0 = count;
        count --;
        if (tmp___0 > 0) {

        } else {
          break;
        }
        (p->top) --;
        data = *(p->top);
        tmp = __builtin_expect((long )((unsigned int )p->top == (unsigned int )((void **)((char *)p + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)))), 0L);
        if (tmp) {
          r = p;
          (executor_globals.argument_stack)->prev = p->prev;
          p = p->prev;
          _efree((void *)r);
        } else {

        }
        *((void **)((char *)executor_globals.argument_stack + (((sizeof(struct _zend_vm_stack ) + 4U) - 1U) & 4294967292U)) + count) = data;
      }
      tmp___1 = (executor_globals.argument_stack)->top;
      ((executor_globals.argument_stack)->top) ++;
      return (tmp___1);
    } else {

    }
  }
  *((executor_globals.argument_stack)->top) = (void *)((unsigned long )count);
  tmp___4 = (executor_globals.argument_stack)->top;
  ((executor_globals.argument_stack)->top) ++;
  return (tmp___4);
}
}
__inline static void ( __attribute__((__always_inline__)) zend_vm_stack_clear_multiple)(void) 
{ void **p ;
  int delete_count ;
  zval *q ;

  {
  p = (executor_globals.argument_stack)->top - 1;
  delete_count = (int )((unsigned long )*p);
  while (1) {
    delete_count --;
    if (delete_count >= 0) {

    } else {
      break;
    }
    p --;
    q = *((zval **)p);
    *p = (void *)0;
    i_zval_ptr_dtor(q);
  }
  zend_vm_stack_free_int((void *)p);
  return;
}
}
__inline static zval **( __attribute__((__always_inline__)) zend_vm_stack_get_arg)(int requested_arg ) 
{ void **p ;
  int arg_count ;
  long tmp ;

  {
  p = ((executor_globals.current_execute_data)->prev_execute_data)->function_state.arguments;
  arg_count = (int )((unsigned long )*p);
  tmp = __builtin_expect((long )(requested_arg > arg_count), 0L);
  if (tmp) {
    return ((zval **)((void *)0));
  } else {

  }
  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 ;

  {
  zend_ptr_stack_2_pop(stack, & a, & b);
  *object = (zval *)a;
  *fbc = (zend_function *)b;
  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 ;

  {
  zend_ptr_stack_3_pop(stack, & a, & b, & c);
  *called_scope = (zend_class_entry *)a;
  *object = (zval *)b;
  *fbc = (zend_function *)c;
  return;
}
}
extern void execute_new_code(void) ;
extern char const __attribute__((__visibility__("default")))  *get_active_class_name(char const   **space ) ;
extern char const __attribute__((__visibility__("default")))  *get_active_function_name(void) ;
extern char const __attribute__((__visibility__("default")))  *zend_get_executed_filename(void) ;
extern uint __attribute__((__visibility__("default")))  zend_get_executed_lineno(void) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_executing(void) ;
extern void __attribute__((__visibility__("default")))  zend_set_timeout(long seconds , int reset_signals ) ;
extern void __attribute__((__visibility__("default")))  zend_unset_timeout(void) ;
extern void __attribute__((__visibility__("default")))  zend_timeout(int dummy ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_fetch_class(char const   *class_name , uint class_name_len , int fetch_type ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_fetch_class_by_name(char const   *class_name , uint class_name_len , zend_literal const   *key , int fetch_type ) ;
extern void zend_verify_abstract_class(zend_class_entry *ce ) ;
extern zval __attribute__((__visibility__("default")))  **zend_get_compiled_variable_value(zend_execute_data const   *execute_data_ptr , zend_uint var ) ;
extern int __attribute__((__visibility__("default")))  zend_set_user_opcode_handler(zend_uchar opcode , int (*handler)(zend_execute_data *execute_data ) ) ;
extern user_opcode_handler_t __attribute__((__visibility__("default")))  zend_get_user_opcode_handler(zend_uchar opcode ) ;
extern zval __attribute__((__visibility__("default")))  *zend_get_zval_ptr(int op_type , znode_op const   *node , temp_variable const   *Ts , zend_free_op *should_free , int type ) ;
extern zval __attribute__((__visibility__("default")))  **zend_get_zval_ptr_ptr(int op_type , znode_op const   *node , temp_variable const   *Ts , zend_free_op *should_free , int type ) ;
extern int __attribute__((__visibility__("default")))  zend_do_fcall(zend_execute_data *execute_data ) ;
extern int zend_next_free_module(void) ;
extern int __attribute__((__visibility__("default")))  zend_get_parameters(int ht , int param_count  , ...) ;
extern int __attribute__((__visibility__("default")))  _zend_get_parameters_array(int ht , int param_count , zval **argument_array ) ;
extern int __attribute__((__visibility__("default"), __deprecated__))  zend_get_parameters_ex(int param_count  , ...) ;
extern int __attribute__((__visibility__("default")))  _zend_get_parameters_array_ex(int param_count , zval ***argument_array ) ;
extern int __attribute__((__visibility__("default")))  zend_copy_parameters_array(int param_count , zval *argument_array ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_parameters(int num_args , char const   *type_spec  , ...) ;
extern int __attribute__((__visibility__("default")))  zend_parse_parameters_ex(int flags , int num_args , char const   *type_spec  , ...) ;
extern char __attribute__((__visibility__("default")))  *zend_zval_type_name(zval const   *arg ) ;
extern int __attribute__((__visibility__("default")))  zend_parse_method_parameters(int num_args , zval *this_ptr , char const   *type_spec  , ...) ;
extern int __attribute__((__visibility__("default")))  zend_parse_method_parameters_ex(int flags , int num_args , zval *this_ptr , char const   *type_spec  , ...) ;
extern int __attribute__((__visibility__("default")))  zend_register_functions(zend_class_entry *scope , zend_function_entry const   *functions , HashTable *function_table , int type ) ;
extern void __attribute__((__visibility__("default")))  zend_unregister_functions(zend_function_entry const   *functions , int count , HashTable *function_table ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_module(zend_module_entry *module_entry ) ;
extern zend_module_entry __attribute__((__visibility__("default")))  *zend_register_internal_module(zend_module_entry *module_entry ) ;
extern zend_module_entry __attribute__((__visibility__("default")))  *zend_register_module_ex(zend_module_entry *module ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_module_ex(zend_module_entry *module ) ;
extern int __attribute__((__visibility__("default")))  zend_startup_modules(void) ;
extern void __attribute__((__visibility__("default")))  zend_collect_module_handlers(void) ;
extern void __attribute__((__visibility__("default")))  zend_destroy_modules(void) ;
extern void __attribute__((__visibility__("default")))  zend_check_magic_method_implementation(zend_class_entry const   *ce , zend_function const   *fptr , int error_type ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_class(zend_class_entry *class_entry ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_class_ex(zend_class_entry *class_entry , zend_class_entry *parent_ce , char *parent_name ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_register_internal_interface(zend_class_entry *orig_class_entry ) ;
extern void __attribute__((__visibility__("default")))  zend_class_implements(zend_class_entry *class_entry , int num_interfaces  , ...) ;
extern int __attribute__((__visibility__("default")))  zend_register_class_alias_ex(char const   *name , int name_len , zend_class_entry *ce ) ;
extern int __attribute__((__visibility__("default")))  zend_disable_function(char *function_name , uint function_name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_disable_class(char *class_name , uint class_name_length ) ;
extern void __attribute__((__visibility__("default")))  zend_wrong_param_count(void) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_callable_ex(zval *callable , zval *object_ptr , uint check_flags , char **callable_name , int *callable_name_len , zend_fcall_info_cache *fcc , char **error ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_is_callable(zval *callable , uint check_flags , char **callable_name ) ;
extern zend_bool __attribute__((__visibility__("default")))  zend_make_callable(zval *callable , char **callable_name ) ;
extern char const __attribute__((__visibility__("default")))  *zend_get_module_version(char const   *module_name ) ;
extern int __attribute__((__visibility__("default")))  zend_get_module_started(char const   *module_name ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property(zend_class_entry *ce , char const   *name , int name_length , zval *property , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_ex(zend_class_entry *ce , char const   *name , int name_length , zval *property , int access_type , char const   *doc_comment , int doc_comment_len ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_null(zend_class_entry *ce , char const   *name , int name_length , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_bool(zend_class_entry *ce , char const   *name , int name_length , long value , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_long(zend_class_entry *ce , char const   *name , int name_length , long value , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_double(zend_class_entry *ce , char const   *name , int name_length , double value , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_string(zend_class_entry *ce , char const   *name , int name_length , char const   *value , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_property_stringl(zend_class_entry *ce , char const   *name , int name_length , char const   *value , int value_len , int access_type ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant(zend_class_entry *ce , char const   *name , size_t name_length , zval *value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_null(zend_class_entry *ce , char const   *name , size_t name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_long(zend_class_entry *ce , char const   *name , size_t name_length , long value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_bool(zend_class_entry *ce , char const   *name , size_t name_length , zend_bool value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_double(zend_class_entry *ce , char const   *name , size_t name_length , double value ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_stringl(zend_class_entry *ce , char const   *name , size_t name_length , char const   *value , size_t value_length ) ;
extern int __attribute__((__visibility__("default")))  zend_declare_class_constant_string(zend_class_entry *ce , char const   *name , size_t name_length , char const   *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_class_constants(zend_class_entry *class_type ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property(zend_class_entry *scope , zval *object , char const   *name , int name_length , zval *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_null(zend_class_entry *scope , zval *object , char const   *name , int name_length ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_bool(zend_class_entry *scope , zval *object , char const   *name , int name_length , long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_long(zend_class_entry *scope , zval *object , char const   *name , int name_length , long value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_double(zend_class_entry *scope , zval *object , char const   *name , int name_length , double value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_string(zend_class_entry *scope , zval *object , char const   *name , int name_length , char const   *value ) ;
extern void __attribute__((__visibility__("default")))  zend_update_property_stringl(zend_class_entry *scope , zval *object , char const   *name , int name_length , char const   *value , int value_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property(zend_class_entry *scope , char const   *name , int name_length , zval *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_null(zend_class_entry *scope , char const   *name , int name_length ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_bool(zend_class_entry *scope , char const   *name , int name_length , long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_long(zend_class_entry *scope , char const   *name , int name_length , long value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_double(zend_class_entry *scope , char const   *name , int name_length , double value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_string(zend_class_entry *scope , char const   *name , int name_length , char const   *value ) ;
extern int __attribute__((__visibility__("default")))  zend_update_static_property_stringl(zend_class_entry *scope , char const   *name , int name_length , char const   *value , int value_length ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_property(zend_class_entry *scope , zval *object , char const   *name , int name_length , zend_bool silent ) ;
extern zval __attribute__((__visibility__("default")))  *zend_read_static_property(zend_class_entry *scope , char const   *name , int name_length , zend_bool silent ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *zend_get_class_entry(zval const   *zobject ) ;
extern int __attribute__((__visibility__("default")))  zend_get_object_classname(zval const   *object , char const   **class_name , zend_uint *class_name_len ) ;
extern char __attribute__((__visibility__("default")))  *zend_get_type_by_const(int type ) ;
extern int __attribute__((__visibility__("default")))  _array_init(zval *arg , uint size ) ;
extern int __attribute__((__visibility__("default")))  _object_init(zval *arg ) ;
extern int __attribute__((__visibility__("default")))  _object_init_ex(zval *arg , zend_class_entry *ce ) ;
extern int __attribute__((__visibility__("default")))  _object_and_properties_init(zval *arg , zend_class_entry *ce , HashTable *properties ) ;
extern void __attribute__((__visibility__("default")))  object_properties_init(zend_object *object , zend_class_entry *class_type ) ;
extern void __attribute__((__visibility__("default")))  zend_merge_properties(zval *obj , HashTable *properties , int destroy_ht ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_function(zval *arg , char const   *key , void (*function_ptr)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_long_ex(zval *arg , char const   *key , uint key_len , long n ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_null_ex(zval *arg , char const   *key , uint key_len ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_bool_ex(zval *arg , char const   *key , uint key_len , int b ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_resource_ex(zval *arg , char const   *key , uint key_len , int r ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_double_ex(zval *arg , char const   *key , uint key_len , double d ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_string_ex(zval *arg , char const   *key , uint key_len , char *str , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_stringl_ex(zval *arg , char const   *key , uint key_len , char *str , uint length , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_assoc_zval_ex(zval *arg , char const   *key , uint key_len , zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_index_long(zval *arg , ulong idx , long n ) ;
extern int __attribute__((__visibility__("default")))  add_index_null(zval *arg , ulong idx ) ;
extern int __attribute__((__visibility__("default")))  add_index_bool(zval *arg , ulong idx , int b ) ;
extern int __attribute__((__visibility__("default")))  add_index_resource(zval *arg , ulong idx , int r ) ;
extern int __attribute__((__visibility__("default")))  add_index_double(zval *arg , ulong idx , double d ) ;
extern int __attribute__((__visibility__("default")))  add_index_string(zval *arg , ulong idx , char const   *str , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_index_stringl(zval *arg , ulong idx , char const   *str , uint length , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_index_zval(zval *arg , ulong index , zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_long(zval *arg , long n ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_null(zval *arg ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_bool(zval *arg , int b ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_resource(zval *arg , int r ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_double(zval *arg , double d ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_string(zval *arg , char const   *str , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_stringl(zval *arg , char const   *str , uint length , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_next_index_zval(zval *arg , zval *value ) ;
extern int __attribute__((__visibility__("default")))  add_get_assoc_string_ex(zval *arg , char const   *key , uint key_len , char const   *str , void **dest , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_get_assoc_stringl_ex(zval *arg , char const   *key , uint key_len , char const   *str , uint length , void **dest , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_long(zval *arg , ulong idx , long l , void **dest ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_double(zval *arg , ulong idx , double d , void **dest ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_string(zval *arg , ulong idx , char const   *str , void **dest , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_get_index_stringl(zval *arg , ulong idx , char const   *str , uint length , void **dest , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_property_long_ex(zval *arg , char const   *key , uint key_len , long l ) ;
extern int __attribute__((__visibility__("default")))  add_property_null_ex(zval *arg , char const   *key , uint key_len ) ;
extern int __attribute__((__visibility__("default")))  add_property_bool_ex(zval *arg , char const   *key , uint key_len , int b ) ;
extern int __attribute__((__visibility__("default")))  add_property_resource_ex(zval *arg , char const   *key , uint key_len , long r ) ;
extern int __attribute__((__visibility__("default")))  add_property_double_ex(zval *arg , char const   *key , uint key_len , double d ) ;
extern int __attribute__((__visibility__("default")))  add_property_string_ex(zval *arg , char const   *key , uint key_len , char const   *str , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_property_stringl_ex(zval *arg , char const   *key , uint key_len , char const   *str , uint length , int duplicate ) ;
extern int __attribute__((__visibility__("default")))  add_property_zval_ex(zval *arg , char const   *key , uint key_len , zval *value ) ;
extern int __attribute__((__visibility__("default")))  call_user_function(HashTable *function_table , zval **object_pp , zval *function_name , zval *retval_ptr , zend_uint param_count , zval **params ) ;
extern int __attribute__((__visibility__("default")))  call_user_function_ex(HashTable *function_table , zval **object_pp , zval *function_name , zval **retval_ptr_ptr , zend_uint param_count , zval ***params , int no_separation , HashTable *symbol_table ) ;
extern zend_fcall_info const __attribute__((__visibility__("default")))  empty_fcall_info ;
extern zend_fcall_info_cache const __attribute__((__visibility__("default")))  empty_fcall_info_cache ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_init(zval *callable , uint check_flags , zend_fcall_info *fci , zend_fcall_info_cache *fcc , char **callable_name , char **error ) ;
extern void __attribute__((__visibility__("default")))  zend_fcall_info_args_clear(zend_fcall_info *fci , int free_mem ) ;
extern void __attribute__((__visibility__("default")))  zend_fcall_info_args_save(zend_fcall_info *fci , int *param_count , zval ****params ) ;
extern void __attribute__((__visibility__("default")))  zend_fcall_info_args_restore(zend_fcall_info *fci , int param_count , zval ***params ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_args(zend_fcall_info *fci , zval *args ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argp(zend_fcall_info *fci , int argc , zval ***argv ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argv(zend_fcall_info *fci , int argc , va_list *argv ) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_argn(zend_fcall_info *fci , int argc  , ...) ;
extern int __attribute__((__visibility__("default")))  zend_fcall_info_call(zend_fcall_info *fci , zend_fcall_info_cache *fcc , zval **retval , zval *args ) ;
extern int __attribute__((__visibility__("default")))  zend_call_function(zend_fcall_info *fci , zend_fcall_info_cache *fci_cache ) ;
extern int __attribute__((__visibility__("default")))  zend_set_hash_symbol(zval *symbol , char const   *name , int name_length , zend_bool is_ref , int num_symbol_tables  , ...) ;
extern void __attribute__((__visibility__("default")))  zend_delete_variable(zend_execute_data *ex , HashTable *ht , char const   *name , int name_len , ulong hash_value ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable(char const   *name , int name_len ) ;
extern int __attribute__((__visibility__("default")))  zend_delete_global_variable_ex(char const   *name , int name_len , ulong hash_value ) ;
extern void __attribute__((__visibility__("default")))  zend_reset_all_cv(HashTable *symbol_table ) ;
extern void __attribute__((__visibility__("default")))  zend_rebuild_symbol_table(void) ;
extern void __attribute__((__visibility__("default")))  zif_display_disabled_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_display_disabled_class(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern 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 ;

  {
  if (__c >= -128) {
    if (__c < 256) {
      tmp = __ctype_tolower_loc();
      tmp___0 = *(*tmp + __c);
    } else {
      tmp___0 = (int const   )__c;
    }
  } else {
    tmp___0 = (int const   )__c;
  }
  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 ;

  {
  if (__c >= -128) {
    if (__c < 256) {
      tmp = __ctype_toupper_loc();
      tmp___0 = *(*tmp + __c);
    } else {
      tmp___0 = (int const   )__c;
    }
  } else {
    tmp___0 = (int const   )__c;
  }
  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 int __attribute__((__visibility__("default")))  php_get_module_initialized(void) ;
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 ) 
{ 

  {
  zend_replace_error_handling(error_handling, exception_class, (zend_error_handling *)((void *)0));
  return;
}
}
__inline static void __attribute__((__deprecated__))  php_std_error_handling(void) 
{ 

  {
  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 const __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 php_output_handler __attribute__((__visibility__("default")))  *php_output_get_active_handler(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 ;

  {
  tmp = __xstat(3, (char const   *)__path, (struct stat *)__statbuf);
  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 ;

  {
  tmp = __lxstat(3, (char const   *)__path, (struct stat *)__statbuf);
  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 ;

  {
  tmp = __fxstat(3, __fd, __statbuf);
  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 ;

  {
  tmp = __fxstatat(3, __fd, (char const   *)__filename, (struct stat *)__statbuf, __flag);
  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 ;

  {
  tmp = __xmknod(1, __path, __mode, & __dev);
  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 ;

  {
  tmp = __xmknodat(1, __fd, __path, __mode, & __dev);
  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 ;

  {
  tmp = __xstat64(3, (char const   *)__path, (struct stat64 *)__statbuf);
  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 ;

  {
  tmp = __lxstat64(3, (char const   *)__path, (struct stat64 *)__statbuf);
  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 ;

  {
  tmp = __fxstat64(3, __fd, __statbuf);
  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 ;

  {
  tmp = __fxstatat64(3, __fd, (char const   *)__filename, (struct stat64 *)__statbuf, __flag);
  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 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 int __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 ) 
{ 

  {
  if (__cmsg->cmsg_len < sizeof(struct cmsghdr )) {
    return ((struct cmsghdr *)0);
  } else {

  }
  __cmsg = (struct cmsghdr *)((unsigned char *)__cmsg + (((__cmsg->cmsg_len + sizeof(size_t )) - 1U) & ~ (sizeof(size_t ) - 1U)));
  if ((unsigned int )((unsigned char *)(__cmsg + 1)) > (unsigned int )((unsigned char *)__mhdr->msg_control + __mhdr->msg_controllen)) {
    return ((struct cmsghdr *)0);
  } else {
    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)) {
      return ((struct cmsghdr *)0);
    } else {

    }
  }
  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 char __attribute__((__visibility__("default")))  *expand_filepath_with_mode(char const   *filepath , char *real_path , char const   *relative_to , size_t relative_to_len , int use_realpath ) ;
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 void __attribute__((__visibility__("default")))  php_request_shutdown_for_hook(void *dummy ) ;
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 ) ;
void php_call_shutdown_functions(void) ;
void php_free_shutdown_functions(void) ;
extern int php_init_environ(void) ;
extern int php_shutdown_environ(void) ;
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 ;

  {
  tmp = __btowc_alias(__c);
  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 ;

  {
  tmp = __wctob_alias(__wc);
  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 ;

  {
  if ((unsigned int )__ps != (unsigned int )((void *)0)) {
    tmp = mbrtowc((wchar_t */* __restrict  */)((void *)0), __s, __n, (mbstate_t *)__ps);
    tmp___1 = tmp;
  } else {
    tmp___0 = __mbrlen(__s, __n, (mbstate_t */* __restrict  */)((void *)0));
    tmp___1 = tmp___0;
  }
  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) ;
zend_module_entry basic_functions_module ;
int zm_startup_basic(int type , int module_number ) ;
int zm_shutdown_basic(int type , int module_number ) ;
int zm_activate_basic(int type , int module_number ) ;
int zm_deactivate_basic(int type , int module_number ) ;
void zm_info_basic(zend_module_entry *zend_module ) ;
void zif_constant(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_sleep(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_usleep(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_time_nanosleep(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_time_sleep_until(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_flush(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void php_inet_ntop(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void php_inet_pton(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_ip2long(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_long2ip(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_getenv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_putenv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_getopt(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
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 ) ;
void zif_get_cfg_var(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_set_magic_quotes_runtime(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_get_magic_quotes_runtime(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_get_magic_quotes_gpc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_error_log(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_error_get_last(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_call_user_func(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_call_user_func_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_call_user_method(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_call_user_method_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_forward_static_call(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_forward_static_call_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_register_shutdown_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_highlight_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_highlight_string(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_php_strip_whitespace(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void __attribute__((__visibility__("default")))  php_get_highlight_struct(zend_syntax_highlighter_ini *syntax_highlighter_ini___0 ) ;
void zif_ini_get(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_ini_get_all(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_ini_set(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_ini_restore(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_get_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_set_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_restore_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
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 ) ;
void zif_connection_aborted(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_connection_status(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_ignore_user_abort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_getservbyname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_getservbyport(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_getprotobyname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
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 ) ;
void zif_register_tick_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_unregister_tick_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_sys_getloadavg(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_is_uploaded_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_move_uploaded_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
void zif_parse_ini_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
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 zm_deactivate_browscap(int type , int module_number ) ;
int __attribute__((__visibility__("default")))  _php_error_log(int opt_err , char *message , char *opt , char *headers ) ;
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 ) ;
php_basic_globals __attribute__((__visibility__("default")))  basic_globals  ;
double __attribute__((__visibility__("default")))  php_get_nan(void) ;
double __attribute__((__visibility__("default")))  php_get_inf(void) ;
zend_bool __attribute__((__visibility__("default")))  register_user_shutdown_function(char *function_name , size_t function_len , php_shutdown_function_entry *shutdown_function_entry ) ;
zend_bool __attribute__((__visibility__("default")))  remove_user_shutdown_function(char *function_name , size_t function_len ) ;
zend_bool __attribute__((__visibility__("default")))  append_user_shutdown_function(php_shutdown_function_entry shutdown_function_entry ) ;
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 void zif_strspn(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strcspn(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_replace(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_ireplace(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rtrim(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_trim(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_ltrim(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_soundex(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_levenshtein(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_count_chars(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_wordwrap(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_explode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_implode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strtok(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strtoupper(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strtolower(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_basename(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_dirname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_pathinfo(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strstr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strpos(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stripos(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strrpos(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strripos(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strrchr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_substr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_quotemeta(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_ucfirst(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_lcfirst(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_ucwords(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strtr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strrev(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hebrev(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hebrevc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_user_sprintf(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_user_printf(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_vprintf(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_vsprintf(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_addcslashes(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_addslashes(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stripcslashes(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stripslashes(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_chr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_ord(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_nl2br(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_setlocale(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_localeconv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_nl_langinfo(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stristr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_chunk_split(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_parse_str(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_getcsv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_bin2hex(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hex2bin(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_similar_text(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strip_tags(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_repeat(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_substr_replace(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strnatcmp(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strnatcasecmp(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_substr_count(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_pad(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_sscanf(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_shuffle(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_word_count(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_str_split(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strpbrk(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_substr_compare(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strcoll(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_money_format(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_nl_langinfo(int type , int module_number ) ;
extern int __attribute__((__visibility__("default")))  strnatcmp_ex(char const   *a , size_t a_len , char const   *b , size_t b_len , int fold_case ) ;
extern struct lconv  __attribute__((__visibility__("default"))) *localeconv_r(struct lconv *out ) ;
extern char __attribute__((__visibility__("default")))  *php_strtoupper(char *s , size_t len ) ;
extern char __attribute__((__visibility__("default")))  *php_strtolower(char *s , size_t len ) ;
extern char __attribute__((__visibility__("default")))  *php_strtr(char *str , int len , char *str_from , char *str_to , int trlen ) ;
extern char __attribute__((__visibility__("default")))  *php_addslashes(char *str , int length , int *new_length , int freeit ) ;
extern char __attribute__((__visibility__("default")))  *php_addcslashes(char const   *str , int length , int *new_length , int freeit , char *what , int wlength ) ;
extern void __attribute__((__visibility__("default")))  php_stripslashes(char *str , int *len ) ;
extern void __attribute__((__visibility__("default")))  php_stripcslashes(char *str , int *len ) ;
extern void __attribute__((__visibility__("default")))  php_basename(char const   *s , size_t len , char *suffix , size_t sufflen , char **p_ret , size_t *p_len ) ;
extern size_t __attribute__((__visibility__("default")))  php_dirname(char *str , size_t len ) ;
extern char __attribute__((__visibility__("default")))  *php_stristr(char *s , char *t , size_t s_len , size_t t_len ) ;
extern char __attribute__((__visibility__("default")))  *php_str_to_str_ex(char *haystack , int length , char *needle , int needle_len , char *str , int str_len , int *_new_length , int case_sensitivity , int *replace_count ) ;
extern char __attribute__((__visibility__("default")))  *php_str_to_str(char *haystack , int length , char *needle , int needle_len , char *str , int str_len , int *_new_length ) ;
extern char __attribute__((__visibility__("default")))  *php_trim(char *c , int len , char *what , int what_len , zval *return_value , int mode ) ;
extern size_t __attribute__((__visibility__("default")))  php_strip_tags(char *rbuf , int len , int *state , char *allow , int allow_len ) ;
extern size_t __attribute__((__visibility__("default")))  php_strip_tags_ex(char *rbuf , int len , int *stateptr , char *allow , int allow_len , zend_bool allow_tag_spaces ) ;
extern int __attribute__((__visibility__("default")))  php_char_to_str_ex(char *str , uint len , char from , char *to , int to_len , zval *result , int case_sensitivity , int *replace_count ) ;
extern int __attribute__((__visibility__("default")))  php_char_to_str(char *str , uint len , char from , char *to , int to_len , zval *result ) ;
extern void __attribute__((__visibility__("default")))  php_implode(zval *delim , zval *arr , zval *return_value ) ;
extern void __attribute__((__visibility__("default")))  php_explode(zval *delim , zval *str , zval *return_value , long limit ) ;
extern size_t __attribute__((__visibility__("default")))  php_strspn(char *s1 , char *s2 , char *s1_end , char *s2_end ) ;
extern size_t __attribute__((__visibility__("default")))  php_strcspn(char *s1 , char *s2 , char *s1_end , char *s2_end ) ;
extern int __attribute__((__visibility__("default")))  string_natural_compare_function_ex(zval *result , zval *op1 , zval *op2 , zend_bool case_insensitive ) ;
extern int __attribute__((__visibility__("default")))  string_natural_compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern int __attribute__((__visibility__("default")))  string_natural_case_compare_function(zval *result , zval *op1 , zval *op2 ) ;
extern void register_string_constants(int type , int module_number ) ;
extern void zif_base64_decode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_base64_encode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern unsigned char __attribute__((__visibility__("default")))  *php_base64_encode(unsigned char const   * , int  , int * ) ;
extern unsigned char __attribute__((__visibility__("default")))  *php_base64_decode_ex(unsigned char const   * , int  , int * , zend_bool  ) ;
extern unsigned char __attribute__((__visibility__("default")))  *php_base64_decode(unsigned char const   * , int  , int * ) ;
extern int zm_startup_dir(int type , int module_number ) ;
extern int zm_activate_dir(int type , int module_number ) ;
extern void zif_opendir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_closedir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_chdir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getcwd(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rewinddir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void php_if_readdir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getdir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_glob(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_scandir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_gethostbyaddr(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_gethostbyname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_gethostbynamel(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_gethostname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_dns_check_record(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_dns_get_mx(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_dns_get_record(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_dns(int type , int module_number ) ;
extern void zif_mail(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zm_info_mail(zend_module_entry *zend_module ) ;
extern void zif_ezmlm_hash(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int __attribute__((__visibility__("default")))  php_mail(char *to , char *subject , char *message , char *headers , char *extra_cmd ) ;
extern void __attribute__((__visibility__("default")))  make_digest(char *md5str , unsigned char const   *digest ) ;
extern void __attribute__((__visibility__("default")))  make_digest_ex(char *md5str , unsigned char const   *digest , int len ) ;
extern void php_if_md5(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void php_if_md5_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  PHP_MD5Init(PHP_MD5_CTX *ctx ) ;
extern void __attribute__((__visibility__("default")))  PHP_MD5Update(PHP_MD5_CTX *ctx , void const   *data , size_t size ) ;
extern void __attribute__((__visibility__("default")))  PHP_MD5Final(unsigned char *result , PHP_MD5_CTX *ctx ) ;
extern void __attribute__((__visibility__("default")))  PHP_SHA1Init(PHP_SHA1_CTX * ) ;
extern void __attribute__((__visibility__("default")))  PHP_SHA1Update(PHP_SHA1_CTX * , unsigned char const   * , unsigned int  ) ;
extern void __attribute__((__visibility__("default")))  PHP_SHA1Final(unsigned char * , PHP_SHA1_CTX * ) ;
extern void __attribute__((__visibility__("default")))  make_sha1_digest(char *sha1str , unsigned char *digest ) ;
extern void zif_sha1(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_sha1_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void register_html_constants(int type , int module_number ) ;
extern void zif_htmlspecialchars(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_htmlentities(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_htmlspecialchars_decode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_html_entity_decode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_get_html_translation_table(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern char __attribute__((__visibility__("default")))  *php_escape_html_entities(unsigned char *old , size_t oldlen , size_t *newlen , int all , int flags , char *hint_charset ) ;
extern char __attribute__((__visibility__("default")))  *php_escape_html_entities_ex(unsigned char *old , size_t oldlen , size_t *newlen , int all , int flags , char *hint_charset , zend_bool double_encode ) ;
extern char __attribute__((__visibility__("default")))  *php_unescape_html_entities(unsigned char *old , size_t oldlen , size_t *newlen , int all , int flags , char *hint_charset ) ;
extern unsigned int __attribute__((__visibility__("default")))  php_next_utf8_char(unsigned char const   *str , size_t str_len , size_t *cursor , int *status ) ;
extern void zif_system(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_exec(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_escapeshellcmd(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_escapeshellarg(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_passthru(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_shell_exec(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_proc_open(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_proc_get_status(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_proc_close(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_proc_terminate(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_proc_nice(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_proc_open(int type , int module_number ) ;
extern char __attribute__((__visibility__("default")))  *php_escape_shell_cmd(char * ) ;
extern char __attribute__((__visibility__("default")))  *php_escape_shell_arg(char * ) ;
extern int __attribute__((__visibility__("default")))  php_exec(int type , char *cmd , zval *array , zval *return_value ) ;
extern int zm_startup_file(int type , int module_number ) ;
extern int zm_shutdown_file(int type , int module_number ) ;
extern void zif_tempnam(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void php_if_tmpfile(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void php_if_fopen(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fclose(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_popen(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_pclose(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_feof(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fread(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fgetc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fgets(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_fscanf(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fgetss(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_fgetcsv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_fputcsv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fwrite(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fflush(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_rewind(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_ftell(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fseek(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_mkdir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rmdir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  zif_fpassthru(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_readfile(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_umask(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rename(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_unlink(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_copy(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_file_get_contents(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_file_put_contents(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_get_meta_tags(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_flock(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_fd_set(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_fd_isset(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_realpath(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_fnmatch(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void php_if_ftruncate(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void php_if_fstat(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_sys_get_temp_dir(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_user_streams(int type , int module_number ) ;
extern int __attribute__((__visibility__("default")))  php_le_stream_context(void) ;
extern int __attribute__((__visibility__("default")))  php_set_sock_blocking(int socketd , int block ) ;
extern int __attribute__((__visibility__("default")))  php_copy_file(char *src , char *dest ) ;
extern int __attribute__((__visibility__("default")))  php_copy_file_ex(char *src , char *dest , int src_chk ) ;
extern int __attribute__((__visibility__("default")))  php_copy_file_ctx(char *src , char *dest , int src_chk , php_stream_context *ctx ) ;
extern int __attribute__((__visibility__("default")))  php_mkdir_ex(char *dir , long mode , int options ) ;
extern int __attribute__((__visibility__("default")))  php_mkdir(char *dir , long mode ) ;
extern void __attribute__((__visibility__("default")))  php_fgetcsv(php_stream *stream , char delimiter , char enclosure , char escape_char , size_t buf_len , char *buf , zval *return_value ) ;
extern int __attribute__((__visibility__("default")))  php_fputcsv(php_stream *stream , zval *fields , char delimiter , char enclosure , char escape_char ) ;
extern php_meta_tags_token php_next_meta_token(php_meta_tags_data * ) ;
extern php_file_globals __attribute__((__visibility__("default")))  file_globals ;
extern void closelog(void) ;
extern void openlog(char const   *__ident , int __option , int __facility ) ;
extern  __attribute__((__nothrow__)) int setlogmask(int __mask ) ;
extern void ( /* format attribute */  syslog)(int __pri , char const   *__fmt  , ...) ;
extern void ( /* format attribute */  vsyslog)(int __pri , char const   *__fmt , __gnuc_va_list __ap ) ;
extern int zm_startup_syslog(int type , int module_number ) ;
extern int zm_activate_syslog(int type , int module_number ) ;
extern int zm_shutdown_syslog(int type , int module_number ) ;
extern void zif_openlog(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_syslog(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_closelog(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_browscap(int type , int module_number ) ;
extern int zm_shutdown_browscap(int type , int module_number ) ;
extern void zif_get_browser(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_pack(int type , int module_number ) ;
extern void zif_pack(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_unpack(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strptime(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern char __attribute__((__visibility__("default")))  *php_std_date(time_t t ) ;
extern void zif_microtime(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_gettimeofday(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getrusage(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  php_url_free(php_url *theurl ) ;
extern php_url __attribute__((__visibility__("default")))  *php_url_parse(char const   *str ) ;
extern php_url __attribute__((__visibility__("default")))  *php_url_parse_ex(char const   *str , int length ) ;
extern int __attribute__((__visibility__("default")))  php_url_decode(char *str , int len ) ;
extern int __attribute__((__visibility__("default")))  php_raw_url_decode(char *str , int len ) ;
extern char __attribute__((__visibility__("default")))  *php_url_encode(char const   *s , int len , int *new_length ) ;
extern char __attribute__((__visibility__("default")))  *php_raw_url_encode(char const   *s , int len , int *new_length ) ;
extern void zif_parse_url(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_urlencode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_urldecode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rawurlencode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rawurldecode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_get_headers(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getmyuid(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getmygid(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getmypid(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getmyinode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getlastmod(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  php_statpage(void) ;
extern long __attribute__((__visibility__("default")))  php_getlastmod(void) ;
extern long php_getuid(void) ;
extern long php_getgid(void) ;
extern void zif_convert_cyr_string(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_link(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_readlink(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_linkinfo(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_symlink(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern char __attribute__((__visibility__("default")))  *php_socket_strerror(long err , char *buf , size_t bufsize ) ;
extern struct in6_addr  const  in6addr_any ;
extern struct in6_addr  const  in6addr_loopback ;
extern  __attribute__((__nothrow__)) uint32_t ntohl(uint32_t __netlong )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) uint16_t ntohs(uint16_t __netshort )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) uint32_t htonl(uint32_t __hostlong )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) uint16_t htons(uint16_t __hostshort )  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int bindresvport(int __sockfd , struct sockaddr_in *__sock_in ) ;
extern  __attribute__((__nothrow__)) int bindresvport6(int __sockfd , struct sockaddr_in6 *__sock_in ) ;
extern  __attribute__((__nothrow__)) int inet6_option_space(int __nbytes )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int inet6_option_init(void *__bp , struct cmsghdr **__cmsgp , int __type )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int inet6_option_append(struct cmsghdr *__cmsg , uint8_t const   *__typep , int __multx , int __plusy )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) uint8_t *inet6_option_alloc(struct cmsghdr *__cmsg , int __datalen , int __multx , int __plusy )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int inet6_option_next(struct cmsghdr  const  *__cmsg , uint8_t **__tptrp )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int inet6_option_find(struct cmsghdr  const  *__cmsg , uint8_t **__tptrp , int __type )  __attribute__((__deprecated__)) ;
extern  __attribute__((__nothrow__)) int inet6_opt_init(void *__extbuf , socklen_t __extlen ) ;
extern  __attribute__((__nothrow__)) int inet6_opt_append(void *__extbuf , socklen_t __extlen , int __offset , uint8_t __type , socklen_t __len , uint8_t __align , void **__databufp ) ;
extern  __attribute__((__nothrow__)) int inet6_opt_finish(void *__extbuf , socklen_t __extlen , int __offset ) ;
extern  __attribute__((__nothrow__)) int inet6_opt_set_val(void *__databuf , int __offset , void *__val , socklen_t __vallen ) ;
extern  __attribute__((__nothrow__)) int inet6_opt_next(void *__extbuf , socklen_t __extlen , int __offset , uint8_t *__typep , socklen_t *__lenp , void **__databufp ) ;
extern  __attribute__((__nothrow__)) int inet6_opt_find(void *__extbuf , socklen_t __extlen , int __offset , uint8_t __type , socklen_t *__lenp , void **__databufp ) ;
extern  __attribute__((__nothrow__)) int inet6_opt_get_val(void *__databuf , int __offset , void *__val , socklen_t __vallen ) ;
extern  __attribute__((__nothrow__)) socklen_t inet6_rth_space(int __type , int __segments ) ;
extern  __attribute__((__nothrow__)) void *inet6_rth_init(void *__bp , socklen_t __bp_len , int __type , int __segments ) ;
extern  __attribute__((__nothrow__)) int inet6_rth_add(void *__bp , struct in6_addr  const  *__addr ) ;
extern  __attribute__((__nothrow__)) int inet6_rth_reverse(void const   *__in , void *__out ) ;
extern  __attribute__((__nothrow__)) int inet6_rth_segments(void const   *__bp ) ;
extern  __attribute__((__nothrow__)) struct in6_addr *inet6_rth_getaddr(void const   *__bp , int __index ) ;
extern  __attribute__((__nothrow__)) int getipv4sourcefilter(int __s , struct in_addr __interface_addr , struct in_addr __group , uint32_t *__fmode , uint32_t *__numsrc , struct in_addr *__slist ) ;
extern  __attribute__((__nothrow__)) int setipv4sourcefilter(int __s , struct in_addr __interface_addr , struct in_addr __group , uint32_t __fmode , uint32_t __numsrc , struct in_addr  const  *__slist ) ;
extern  __attribute__((__nothrow__)) int getsourcefilter(int __s , uint32_t __interface_addr , struct sockaddr  const  *__group , socklen_t __grouplen , uint32_t *__fmode , uint32_t *__numsrc , struct sockaddr_storage *__slist ) ;
extern  __attribute__((__nothrow__)) int setsourcefilter(int __s , uint32_t __interface_addr , struct sockaddr  const  *__group , socklen_t __grouplen , uint32_t __fmode , uint32_t __numsrc , struct sockaddr_storage  const  *__slist ) ;
extern int poll(struct pollfd *__fds , nfds_t __nfds , int __timeout ) ;
extern int ppoll(struct pollfd *__fds , nfds_t __nfds , struct timespec  const  *__timeout , __sigset_t const   *__ss ) ;
__inline static int php_tvtoto(struct timeval *timeouttv ) 
{ 

  {
  if (timeouttv) {
    return ((int )(timeouttv->tv_sec * 1000L + timeouttv->tv_usec / 1000L));
  } else {

  }
  return (-1);
}
}
__inline static int php_pollfd_for(php_socket_t fd , int events , struct timeval *timeouttv ) 
{ php_pollfd p ;
  int n ;
  int tmp ;

  {
  p.fd = fd;
  p.events = (short )events;
  p.revents = (short)0;
  tmp = php_tvtoto(timeouttv);
  n = poll(& p, 1UL, tmp);
  if (n > 0) {
    return ((int )p.revents);
  } else {

  }
  return (n);
}
}
__inline static int php_pollfd_for_ms(php_socket_t fd , int events , int timeout ) 
{ php_pollfd p ;
  int n ;

  {
  p.fd = fd;
  p.events = (short )events;
  p.revents = (short)0;
  n = poll(& p, 1UL, timeout);
  if (n > 0) {
    return ((int )p.revents);
  } else {

  }
  return (n);
}
}
extern void __attribute__((__visibility__("default")))  _php_emit_fd_setsize_warning(int max_fd ) ;
extern int __attribute__((__visibility__("default")))  php_network_getaddresses(char const   *host , int socktype , struct sockaddr ***sal , char **error_string ) ;
extern void __attribute__((__visibility__("default")))  php_network_freeaddresses(struct sockaddr **sal ) ;
extern php_socket_t __attribute__((__visibility__("default")))  php_network_connect_socket_to_host(char const   *host , unsigned short port , int socktype , int asynchronous , struct timeval *timeout , char **error_string , int *error_code , char *bindto , unsigned short bindport ) ;
extern int __attribute__((__visibility__("default")))  php_network_connect_socket(php_socket_t sockfd , struct sockaddr  const  *addr , socklen_t addrlen , int asynchronous , struct timeval *timeout , char **error_string , int *error_code ) ;
extern php_socket_t __attribute__((__visibility__("default")))  php_network_bind_socket_to_local_addr(char const   *host , unsigned int port , int socktype , char **error_string , int *error_code ) ;
extern php_socket_t __attribute__((__visibility__("default")))  php_network_accept_incoming(php_socket_t srvsock , char **textaddr , long *textaddrlen , struct sockaddr **addr , socklen_t *addrlen , struct timeval *timeout , char **error_string , int *error_code ) ;
extern int __attribute__((__visibility__("default")))  php_network_get_sock_name(php_socket_t sock , char **textaddr , long *textaddrlen , struct sockaddr **addr , socklen_t *addrlen ) ;
extern int __attribute__((__visibility__("default")))  php_network_get_peer_name(php_socket_t sock , char **textaddr , long *textaddrlen , struct sockaddr **addr , socklen_t *addrlen ) ;
extern void __attribute__((__visibility__("default")))  php_any_addr(int family , php_sockaddr_storage *addr , unsigned short port ) ;
extern int __attribute__((__visibility__("default")))  php_sockaddr_size(php_sockaddr_storage *addr ) ;
extern php_stream_ops __attribute__((__visibility__("default")))  php_stream_socket_ops ;
extern php_stream_ops php_stream_generic_socket_ops ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_sock_open_from_socket(php_socket_t socket , char const   *persistent_id ) ;
extern php_stream __attribute__((__visibility__("default")))  *_php_stream_sock_open_host(char const   *host , unsigned short port , int socktype , struct timeval *timeout , char const   *persistent_id ) ;
extern void __attribute__((__visibility__("default")))  php_network_populate_name_from_sockaddr(struct sockaddr *sa , socklen_t sl , char **textaddr , long *textaddrlen , struct sockaddr **addr , socklen_t *addrlen ) ;
extern int __attribute__((__visibility__("default")))  php_network_parse_network_address_with_port(char const   *addr , long addrlen , struct sockaddr *sa , socklen_t *sl ) ;
extern void zif_fsockopen(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_pfsockopen(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getimagesize(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_getimagesizefromstring(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_image_type_to_mime_type(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_image_type_to_extension(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_imagetypes(int type , int module_number ) ;
extern int __attribute__((__visibility__("default")))  php_getimagetype(php_stream *stream , char *filetype ) ;
extern char __attribute__((__visibility__("default")))  *php_image_type_to_mime_type(int image_type ) ;
extern void zif_iptcparse(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_iptcembed(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
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 void zif_uniqid(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_var_dump(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_var_export(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_debug_zval_dump(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_serialize(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_unserialize(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_memory_get_usage(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_memory_get_peak_usage(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void __attribute__((__visibility__("default")))  php_var_dump(zval **struc , int level ) ;
extern void __attribute__((__visibility__("default")))  php_var_export(zval **struc , int level ) ;
extern void __attribute__((__visibility__("default")))  php_var_export_ex(zval **struc , int level , smart_str *buf ) ;
extern void __attribute__((__visibility__("default")))  php_debug_zval_dump(zval **struc , int level ) ;
extern void __attribute__((__visibility__("default")))  php_var_serialize(smart_str *buf , zval **struc , php_serialize_data_t *var_hash ) ;
extern int __attribute__((__visibility__("default")))  php_var_unserialize(zval **rval , unsigned char const   **p , unsigned char const   *max , php_unserialize_data_t *var_hash ) ;
extern void __attribute__((__visibility__("default")))  var_replace(php_unserialize_data_t *var_hash , zval *ozval , zval **nzval ) ;
extern void __attribute__((__visibility__("default")))  var_push_dtor(php_unserialize_data_t *var_hash , zval **val ) ;
extern void __attribute__((__visibility__("default")))  var_destroy(php_unserialize_data_t *var_hash ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *php_create_empty_class(char *class_name , int len ) ;
__inline static int php_varname_check(char *name , int name_len , zend_bool silent ) 
{ 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 ;
  int tmp___10 ;
  int tmp___11 ;
  int tmp___12 ;
  int tmp___13 ;
  int tmp___14 ;
  int tmp___15 ;

  {
  if ((unsigned int )name_len == sizeof("GLOBALS") - 1U) {
    tmp___15 = memcmp((void const   *)name, (void const   *)"GLOBALS", sizeof("GLOBALS") - 1U);
    if (tmp___15) {
      goto _L___16;
    } else {
      if (! silent) {
        php_error_docref0((char const   *)((void *)0), 1 << 1L, "Attempted GLOBALS variable overwrite");
      } else {

      }
      return (-1);
    }
  } else {
    _L___16: /* CIL Label */ 
    if ((int )*(name + 0) == 95) {
      if ((unsigned int )name_len == sizeof("_GET") - 1U) {
        tmp___7 = memcmp((void const   *)name, (void const   *)"_GET", sizeof("_GET") - 1U);
        if (tmp___7) {
          goto _L___15;
        } else {
          goto _L___8;
        }
      } else {
        _L___15: /* CIL Label */ 
        if ((unsigned int )name_len == sizeof("_POST") - 1U) {
          tmp___8 = memcmp((void const   *)name, (void const   *)"_POST", sizeof("_POST") - 1U);
          if (tmp___8) {
            goto _L___14;
          } else {
            goto _L___8;
          }
        } else {
          _L___14: /* CIL Label */ 
          if ((unsigned int )name_len == sizeof("_COOKIE") - 1U) {
            tmp___9 = memcmp((void const   *)name, (void const   *)"_COOKIE", sizeof("_COOKIE") - 1U);
            if (tmp___9) {
              goto _L___13;
            } else {
              goto _L___8;
            }
          } else {
            _L___13: /* CIL Label */ 
            if ((unsigned int )name_len == sizeof("_ENV") - 1U) {
              tmp___10 = memcmp((void const   *)name, (void const   *)"_ENV", sizeof("_ENV") - 1U);
              if (tmp___10) {
                goto _L___12;
              } else {
                goto _L___8;
              }
            } else {
              _L___12: /* CIL Label */ 
              if ((unsigned int )name_len == sizeof("_SERVER") - 1U) {
                tmp___11 = memcmp((void const   *)name, (void const   *)"_SERVER", sizeof("_SERVER") - 1U);
                if (tmp___11) {
                  goto _L___11;
                } else {
                  goto _L___8;
                }
              } else {
                _L___11: /* CIL Label */ 
                if ((unsigned int )name_len == sizeof("_SESSION") - 1U) {
                  tmp___12 = memcmp((void const   *)name, (void const   *)"_SESSION", sizeof("_SESSION") - 1U);
                  if (tmp___12) {
                    goto _L___10;
                  } else {
                    goto _L___8;
                  }
                } else {
                  _L___10: /* CIL Label */ 
                  if ((unsigned int )name_len == sizeof("_FILES") - 1U) {
                    tmp___13 = memcmp((void const   *)name, (void const   *)"_FILES", sizeof("_FILES") - 1U);
                    if (tmp___13) {
                      goto _L___9;
                    } else {
                      goto _L___8;
                    }
                  } else {
                    _L___9: /* CIL Label */ 
                    if ((unsigned int )name_len == sizeof("_REQUEST") - 1U) {
                      tmp___14 = memcmp((void const   *)name, (void const   *)"_REQUEST", sizeof("_REQUEST") - 1U);
                      if (tmp___14) {
                        goto _L___7;
                      } else {
                        _L___8: /* CIL Label */ 
                        if (! silent) {
                          php_error_docref0((char const   *)((void *)0), 1 << 1L, "Attempted super-global (%s) variable overwrite", name);
                        } else {

                        }
                        return (-1);
                      }
                    } else {
                      goto _L___7;
                    }
                  }
                }
              }
            }
          }
        }
      }
    } else {
      _L___7: /* CIL Label */ 
      if ((int )*(name + 0) == 72) {
        if ((unsigned int )name_len == sizeof("HTTP_POST_VARS") - 1U) {
          tmp = memcmp((void const   *)name, (void const   *)"HTTP_POST_VARS", sizeof("HTTP_POST_VARS") - 1U);
          if (tmp) {
            goto _L___6;
          } else {
            goto _L;
          }
        } else {
          _L___6: /* CIL Label */ 
          if ((unsigned int )name_len == sizeof("HTTP_GET_VARS") - 1U) {
            tmp___0 = memcmp((void const   *)name, (void const   *)"HTTP_GET_VARS", sizeof("HTTP_GET_VARS") - 1U);
            if (tmp___0) {
              goto _L___5;
            } else {
              goto _L;
            }
          } else {
            _L___5: /* CIL Label */ 
            if ((unsigned int )name_len == sizeof("HTTP_COOKIE_VARS") - 1U) {
              tmp___1 = memcmp((void const   *)name, (void const   *)"HTTP_COOKIE_VARS", sizeof("HTTP_COOKIE_VARS") - 1U);
              if (tmp___1) {
                goto _L___4;
              } else {
                goto _L;
              }
            } else {
              _L___4: /* CIL Label */ 
              if ((unsigned int )name_len == sizeof("HTTP_ENV_VARS") - 1U) {
                tmp___2 = memcmp((void const   *)name, (void const   *)"HTTP_ENV_VARS", sizeof("HTTP_ENV_VARS") - 1U);
                if (tmp___2) {
                  goto _L___3;
                } else {
                  goto _L;
                }
              } else {
                _L___3: /* CIL Label */ 
                if ((unsigned int )name_len == sizeof("HTTP_SERVER_VARS") - 1U) {
                  tmp___3 = memcmp((void const   *)name, (void const   *)"HTTP_SERVER_VARS", sizeof("HTTP_SERVER_VARS") - 1U);
                  if (tmp___3) {
                    goto _L___2;
                  } else {
                    goto _L;
                  }
                } else {
                  _L___2: /* CIL Label */ 
                  if ((unsigned int )name_len == sizeof("HTTP_SESSION_VARS") - 1U) {
                    tmp___4 = memcmp((void const   *)name, (void const   *)"HTTP_SESSION_VARS", sizeof("HTTP_SESSION_VARS") - 1U);
                    if (tmp___4) {
                      goto _L___1;
                    } else {
                      goto _L;
                    }
                  } else {
                    _L___1: /* CIL Label */ 
                    if ((unsigned int )name_len == sizeof("HTTP_RAW_POST_DATA") - 1U) {
                      tmp___5 = memcmp((void const   *)name, (void const   *)"HTTP_RAW_POST_DATA", sizeof("HTTP_RAW_POST_DATA") - 1U);
                      if (tmp___5) {
                        goto _L___0;
                      } else {
                        goto _L;
                      }
                    } else {
                      _L___0: /* CIL Label */ 
                      if ((unsigned int )name_len == sizeof("HTTP_POST_FILES") - 1U) {
                        tmp___6 = memcmp((void const   *)name, (void const   *)"HTTP_POST_FILES", sizeof("HTTP_POST_FILES") - 1U);
                        if (tmp___6) {

                        } else {
                          _L: /* CIL Label */ 
                          if (! silent) {
                            php_error_docref0((char const   *)((void *)0), 1 << 1L, "Attempted long input array (%s) overwrite", name);
                          } else {

                          }
                          return (-1);
                        }
                      } else {

                      }
                    }
                  }
                }
              }
            }
          }
        }
      } else {

      }
    }
  }
  return (0);
}
}
extern unsigned char __attribute__((__visibility__("default")))  *php_quot_print_decode(unsigned char const   *str , size_t length , size_t *ret_length , int replace_us_by_ws ) ;
extern unsigned char __attribute__((__visibility__("default")))  *php_quot_print_encode(unsigned char const   *str , size_t length , size_t *ret_length ) ;
extern void zif_quoted_printable_decode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_quoted_printable_encode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int __attribute__((__visibility__("default")))  php_load_extension(char *filename , int type , int start_now ) ;
extern void __attribute__((__visibility__("default")))  php_dl(char *file , int type , zval *return_value , int start_now ) ;
extern void __attribute__((__visibility__("default")))  zif_dl(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zm_info_dl(zend_module_entry *zend_module ) ;
extern void zif_crypt(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_crypt(int type , int module_number ) ;
extern int zm_shutdown_crypt(int type , int module_number ) ;
extern int zm_activate_crypt(int type , int module_number ) ;
extern int zm_activate_head(int type , int module_number ) ;
extern void zif_header(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_header_remove(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_setcookie(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_setrawcookie(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_headers_sent(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_headers_list(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_http_response_code(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int __attribute__((__visibility__("default")))  php_header(void) ;
extern int __attribute__((__visibility__("default")))  php_setcookie(char *name , int name_len , char *value , int value_len , time_t expires , char *path , int path_len , char *domain , int domain_len , int secure , int url_encode , int httponly ) ;
extern double __attribute__((__visibility__("default")))  php_combined_lcg(void) ;
extern void zif_lcg_value(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_lcg(int type , int module_number ) ;
extern void zif_metaphone(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_array(int type , int module_number ) ;
extern int zm_shutdown_array(int type , int module_number ) ;
extern void zif_ksort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_krsort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_natsort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_natcasesort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_asort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_arsort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_sort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_rsort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_usort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_uasort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_uksort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_walk(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_walk_recursive(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_count(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_end(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_prev(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_next(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_reset(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_current(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_key(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_min(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_max(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_in_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_search(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_extract(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_compact(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_fill(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_fill_keys(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_range(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_shuffle(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_multisort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_push(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_pop(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_shift(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_unshift(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_splice(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_slice(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_merge(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_merge_recursive(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_replace(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_replace_recursive(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_keys(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_values(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_count_values(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_reverse(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_reduce(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_pad(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_flip(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_change_key_case(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_rand(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_unique(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_intersect(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_intersect_key(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_intersect_ukey(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_uintersect(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_intersect_assoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_uintersect_assoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_intersect_uassoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_uintersect_uassoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_diff(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_diff_key(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_diff_ukey(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_udiff(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_diff_assoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_udiff_assoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_diff_uassoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_udiff_uassoc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_sum(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_product(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_filter(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_map(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_key_exists(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_chunk(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_array_combine(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern HashTable __attribute__((__visibility__("default")))  *php_splice(HashTable * , int  , int  , zval *** , int  , HashTable ** ) ;
extern int __attribute__((__visibility__("default")))  php_array_merge(HashTable *dest , HashTable *src , int recursive ) ;
extern int __attribute__((__visibility__("default")))  php_array_replace_recursive(HashTable *dest , HashTable *src ) ;
extern int __attribute__((__visibility__("default")))  php_multisort_compare(void const   *a , void const   *b ) ;
extern int zm_startup_assert(int type , int module_number ) ;
extern int zm_shutdown_assert(int type , int module_number ) ;
extern int zm_activate_assert(int type , int module_number ) ;
extern int zm_deactivate_assert(int type , int module_number ) ;
extern void zm_info_assert(zend_module_entry *zend_module ) ;
extern void zif_assert(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_assert_options(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
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 void zif_ftok(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_intval(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_floatval(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_strval(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_gettype(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_settype(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_null(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_resource(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_bool(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_long(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_float(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_numeric(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_string(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_object(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_scalar(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_is_callable(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int zm_startup_standard_filters(int type , int module_number ) ;
extern int zm_shutdown_standard_filters(int type , int module_number ) ;
__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 ;

  {
  while (1) {
    if (num < 0L) {
      while (1) {
        __p = buf;
        __num = (unsigned long )(- num);
        *__p = (char )'\000';
        while (1) {
          __p --;
          *__p = (char )((int )((char )(__num % 10UL)) + 48);
          __num /= 10UL;
          if (__num > 0UL) {

          } else {
            break;
          }
        }
        r = __p;
        break;
      }
      r --;
      *r = (char )'-';
    } else {
      while (1) {
        __p___0 = buf;
        __num___0 = (unsigned long )num;
        *__p___0 = (char )'\000';
        while (1) {
          __p___0 --;
          *__p___0 = (char )((int )((char )(__num___0 % 10UL)) + 48);
          __num___0 /= 10UL;
          if (__num___0 > 0UL) {

          } else {
            break;
          }
        }
        r = __p___0;
        break;
      }
    }
    break;
  }
  return (r);
}
}
__inline static char *smart_str_print_unsigned(char *buf , long num ) 
{ char *r ;
  char *__p ;
  unsigned long __num ;

  {
  while (1) {
    __p = buf;
    __num = (unsigned long )num;
    *__p = (char )'\000';
    while (1) {
      __p --;
      *__p = (char )((int )((char )(__num % 10UL)) + 48);
      __num /= 10UL;
      if (__num > 0UL) {

      } else {
        break;
      }
    }
    r = __p;
    break;
  }
  return (r);
}
}
extern int __attribute__((__visibility__("default")))  php_url_encode_hash_ex(HashTable *ht , smart_str *formstr , char const   *num_prefix , int num_prefix_len , char const   *key_prefix , int key_prefix_len , char const   *key_suffix , int key_suffix_len , zval *type , char *arg_sep , int enc_type ) ;
extern void zif_http_build_query(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern zend_class_entry __attribute__((__visibility__("default")))  *php_create_incomplete_class(void) ;
extern char __attribute__((__visibility__("default")))  *php_lookup_class_name(zval *object , zend_uint *nlen ) ;
extern void __attribute__((__visibility__("default")))  php_store_class_name(zval *object , char const   *name , zend_uint len ) ;
extern int __attribute__((__visibility__("default")))  php_optidx ;
extern int __attribute__((__visibility__("default")))  php_getopt(int argc , char * const  *argv , opt_struct const   *opts , char **optarg , int *optind , int show_err , int arg_start ) ;
extern php_hash_ops const   php_hash_md2_ops ;
extern php_hash_ops const   php_hash_md4_ops ;
extern php_hash_ops const   php_hash_md5_ops ;
extern php_hash_ops const   php_hash_sha1_ops ;
extern php_hash_ops const   php_hash_sha224_ops ;
extern php_hash_ops const   php_hash_sha256_ops ;
extern php_hash_ops const   php_hash_sha384_ops ;
extern php_hash_ops const   php_hash_sha512_ops ;
extern php_hash_ops const   php_hash_ripemd128_ops ;
extern php_hash_ops const   php_hash_ripemd160_ops ;
extern php_hash_ops const   php_hash_ripemd256_ops ;
extern php_hash_ops const   php_hash_ripemd320_ops ;
extern php_hash_ops const   php_hash_whirlpool_ops ;
extern php_hash_ops const   php_hash_3tiger128_ops ;
extern php_hash_ops const   php_hash_3tiger160_ops ;
extern php_hash_ops const   php_hash_3tiger192_ops ;
extern php_hash_ops const   php_hash_4tiger128_ops ;
extern php_hash_ops const   php_hash_4tiger160_ops ;
extern php_hash_ops const   php_hash_4tiger192_ops ;
extern php_hash_ops const   php_hash_snefru_ops ;
extern php_hash_ops const   php_hash_gost_ops ;
extern php_hash_ops const   php_hash_adler32_ops ;
extern php_hash_ops const   php_hash_crc32_ops ;
extern php_hash_ops const   php_hash_crc32b_ops ;
extern php_hash_ops const   php_hash_fnv132_ops ;
extern php_hash_ops const   php_hash_fnv164_ops ;
extern php_hash_ops const   php_hash_joaat_ops ;
extern php_hash_ops const   php_hash_3haval128_ops ;
extern php_hash_ops const   php_hash_3haval160_ops ;
extern php_hash_ops const   php_hash_3haval192_ops ;
extern php_hash_ops const   php_hash_3haval224_ops ;
extern php_hash_ops const   php_hash_3haval256_ops ;
extern php_hash_ops const   php_hash_4haval128_ops ;
extern php_hash_ops const   php_hash_4haval160_ops ;
extern php_hash_ops const   php_hash_4haval192_ops ;
extern php_hash_ops const   php_hash_4haval224_ops ;
extern php_hash_ops const   php_hash_4haval256_ops ;
extern php_hash_ops const   php_hash_5haval128_ops ;
extern php_hash_ops const   php_hash_5haval160_ops ;
extern php_hash_ops const   php_hash_5haval192_ops ;
extern php_hash_ops const   php_hash_5haval224_ops ;
extern php_hash_ops const   php_hash_5haval256_ops ;
extern zend_module_entry hash_module_entry ;
extern void zif_hash(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_hmac(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_hmac_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_init(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_update(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_update_stream(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_update_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_final(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_hash_algos(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern php_hash_ops const __attribute__((__visibility__("default")))  *php_hash_fetch_ops(char const   *algo , int algo_len ) ;
extern void __attribute__((__visibility__("default")))  php_hash_register_algo(char const   *algo , php_hash_ops const   *ops ) ;
extern int __attribute__((__visibility__("default")))  php_hash_copy(void const   *ops , void *orig_context , void *dest_context ) ;
__inline static void php_hash_bin2hex(char *out , unsigned char const   *in , int in_len ) ;
static char const   hexits[17]  = 
  {      (char const   )'0',      (char const   )'1',      (char const   )'2',      (char const   )'3', 
        (char const   )'4',      (char const   )'5',      (char const   )'6',      (char const   )'7', 
        (char const   )'8',      (char const   )'9',      (char const   )'a',      (char const   )'b', 
        (char const   )'c',      (char const   )'d',      (char const   )'e',      (char const   )'f', 
        (char const   )'\000'};
__inline static void php_hash_bin2hex(char *out , unsigned char const   *in , int in_len ) 
{ int i ;

  {
  i = 0;
  while (i < in_len) {
    *(out + i * 2) = (char )hexits[(int const   )*(in + i) >> 4];
    *(out + (i * 2 + 1)) = (char )hexits[(int const   )*(in + i) & 15];
    i ++;
  }
  return;
}
}
extern char __attribute__((__visibility__("default")))  *php_session_create_id(void **mod_data , int *newlen ) ;
extern zend_module_entry session_module_entry ;
extern void __attribute__((__visibility__("default")))  session_adapt_url(char const   * , size_t  , char ** , size_t * ) ;
extern void __attribute__((__visibility__("default")))  php_add_session_var(char *name , size_t namelen ) ;
extern void __attribute__((__visibility__("default")))  php_set_session_var(char *name , size_t namelen , zval *state_val , php_unserialize_data_t *var_hash ) ;
extern int __attribute__((__visibility__("default")))  php_get_session_var(char *name , size_t namelen , zval ***state_var ) ;
extern int __attribute__((__visibility__("default")))  php_session_register_module(ps_module * ) ;
extern int __attribute__((__visibility__("default")))  php_session_register_serializer(char const   *name , int (*encode)(char **newstr , int *newlen ) , int (*decode)(char const   *val , int vallen ) ) ;
extern void __attribute__((__visibility__("default")))  php_session_set_id(char *id ) ;
extern void __attribute__((__visibility__("default")))  php_session_start(void) ;
extern ps_module __attribute__((__visibility__("default")))  *_php_find_ps_module(char *name ) ;
extern ps_serializer const __attribute__((__visibility__("default")))  *_php_find_ps_serializer(char *name ) ;
extern zend_ps_globals __attribute__((__visibility__("default")))  ps_globals ;
extern void php_session_auto_start(void *data ) ;
extern void php_session_shutdown(void *data ) ;
extern zend_class_entry *php_session_class_entry ;
extern zend_class_entry *php_session_iface_entry ;
extern void zim_SessionHandler_open(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zim_SessionHandler_close(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zim_SessionHandler_read(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zim_SessionHandler_write(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zim_SessionHandler_destroy(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zim_SessionHandler_gc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_convert_uudecode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_convert_uuencode(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern int __attribute__((__visibility__("default")))  php_uudecode(char *src , int src_len , char **dest ) ;
extern int __attribute__((__visibility__("default")))  php_uuencode(char *src , int src_len , char **dest ) ;
extern int zend_ini_scanner_get_lineno(void) ;
extern char *zend_ini_scanner_get_filename(void) ;
extern int zend_ini_open_file_for_scanning(zend_file_handle *fh , int scanner_mode ) ;
extern int zend_ini_prepare_string_for_scanning(char *str , int scanner_mode ) ;
extern int ini_lex(zval *ini_lval ) ;
extern void shutdown_ini_scanner(void) ;
extern void __attribute__((__visibility__("default")))  zend_save_lexical_state(zend_lex_state *lex_state ) ;
extern void __attribute__((__visibility__("default")))  zend_restore_lexical_state(zend_lex_state *lex_state ) ;
extern int __attribute__((__visibility__("default")))  zend_prepare_string_for_scanning(zval *str , char *filename ) ;
extern void __attribute__((__visibility__("default")))  zend_multibyte_yyinput_again(size_t (*old_input_filter)(unsigned char **str , size_t *str_length , unsigned char const   *buf , size_t length ) , zend_encoding const   *old_encoding ) ;
extern int __attribute__((__visibility__("default")))  zend_multibyte_set_filter(zend_encoding const   *onetime_encoding ) ;
extern  __attribute__((__nothrow__)) void setrpcent(int __stayopen ) ;
extern  __attribute__((__nothrow__)) void endrpcent(void) ;
extern  __attribute__((__nothrow__)) struct rpcent *getrpcbyname(char const   *__name ) ;
extern  __attribute__((__nothrow__)) struct rpcent *getrpcbynumber(int __number ) ;
extern  __attribute__((__nothrow__)) struct rpcent *getrpcent(void) ;
extern  __attribute__((__nothrow__)) int getrpcbyname_r(char const   *__name , struct rpcent *__result_buf , char *__buffer , size_t __buflen , struct rpcent **__result ) ;
extern  __attribute__((__nothrow__)) int getrpcbynumber_r(int __number , struct rpcent *__result_buf , char *__buffer , size_t __buflen , struct rpcent **__result ) ;
extern  __attribute__((__nothrow__)) int getrpcent_r(struct rpcent *__result_buf , char *__buffer , size_t __buflen , struct rpcent **__result ) ;
extern  __attribute__((__nothrow__)) int *__h_errno_location(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) void herror(char const   *__str ) ;
extern  __attribute__((__nothrow__)) char const   *hstrerror(int __err_num ) ;
extern void sethostent(int __stay_open ) ;
extern void endhostent(void) ;
extern struct hostent *gethostent(void) ;
extern struct hostent *gethostbyaddr(void const   *__addr , __socklen_t __len , int __type ) ;
extern struct hostent *gethostbyname(char const   *__name ) ;
extern struct hostent *gethostbyname2(char const   *__name , int __af ) ;
extern int gethostent_r(struct hostent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct hostent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern int gethostbyaddr_r(void const   * __restrict  __addr , __socklen_t __len , int __type , struct hostent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct hostent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern int gethostbyname_r(char const   * __restrict  __name , struct hostent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct hostent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern int gethostbyname2_r(char const   * __restrict  __name , int __af , struct hostent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct hostent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern void setnetent(int __stay_open ) ;
extern void endnetent(void) ;
extern struct netent *getnetent(void) ;
extern struct netent *getnetbyaddr(uint32_t __net , int __type ) ;
extern struct netent *getnetbyname(char const   *__name ) ;
extern int getnetent_r(struct netent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct netent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern int getnetbyaddr_r(uint32_t __net , int __type , struct netent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct netent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern int getnetbyname_r(char const   * __restrict  __name , struct netent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct netent ** __restrict  __result , int * __restrict  __h_errnop ) ;
extern void setservent(int __stay_open ) ;
extern void endservent(void) ;
extern struct servent *getservent(void) ;
extern struct servent *getservbyname(char const   *__name , char const   *__proto ) ;
extern struct servent *getservbyport(int __port , char const   *__proto ) ;
extern int getservent_r(struct servent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct servent ** __restrict  __result ) ;
extern int getservbyname_r(char const   * __restrict  __name , char const   * __restrict  __proto , struct servent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct servent ** __restrict  __result ) ;
extern int getservbyport_r(int __port , char const   * __restrict  __proto , struct servent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct servent ** __restrict  __result ) ;
extern void setprotoent(int __stay_open ) ;
extern void endprotoent(void) ;
extern struct protoent *getprotoent(void) ;
extern struct protoent *getprotobyname(char const   *__name ) ;
extern struct protoent *getprotobynumber(int __proto ) ;
extern int getprotoent_r(struct protoent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct protoent ** __restrict  __result ) ;
extern int getprotobyname_r(char const   * __restrict  __name , struct protoent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct protoent ** __restrict  __result ) ;
extern int getprotobynumber_r(int __proto , struct protoent * __restrict  __result_buf , char * __restrict  __buf , size_t __buflen , struct protoent ** __restrict  __result ) ;
extern int setnetgrent(char const   *__netgroup ) ;
extern void endnetgrent(void) ;
extern int getnetgrent(char ** __restrict  __hostp , char ** __restrict  __userp , char ** __restrict  __domainp ) ;
extern int innetgr(char const   *__netgroup , char const   *__host , char const   *__user , char const   *__domain ) ;
extern int getnetgrent_r(char ** __restrict  __hostp , char ** __restrict  __userp , char ** __restrict  __domainp , char * __restrict  __buffer , size_t __buflen ) ;
extern int rcmd(char ** __restrict  __ahost , unsigned short __rport , char const   * __restrict  __locuser , char const   * __restrict  __remuser , char const   * __restrict  __cmd , int * __restrict  __fd2p ) ;
extern int rcmd_af(char ** __restrict  __ahost , unsigned short __rport , char const   * __restrict  __locuser , char const   * __restrict  __remuser , char const   * __restrict  __cmd , int * __restrict  __fd2p , sa_family_t __af ) ;
extern int rexec(char ** __restrict  __ahost , int __rport , char const   * __restrict  __name , char const   * __restrict  __pass , char const   * __restrict  __cmd , int * __restrict  __fd2p ) ;
extern int rexec_af(char ** __restrict  __ahost , int __rport , char const   * __restrict  __name , char const   * __restrict  __pass , char const   * __restrict  __cmd , int * __restrict  __fd2p , sa_family_t __af ) ;
extern int ruserok(char const   *__rhost , int __suser , char const   *__remuser , char const   *__locuser ) ;
extern int ruserok_af(char const   *__rhost , int __suser , char const   *__remuser , char const   *__locuser , sa_family_t __af ) ;
extern int iruserok(uint32_t __raddr , int __suser , char const   *__remuser , char const   *__locuser ) ;
extern int iruserok_af(void const   *__raddr , int __suser , char const   *__remuser , char const   *__locuser , sa_family_t __af ) ;
extern int rresvport(int *__alport ) ;
extern int rresvport_af(int *__alport , sa_family_t __af ) ;
extern int getaddrinfo(char const   * __restrict  __name , char const   * __restrict  __service , struct addrinfo  const  * __restrict  __req , struct addrinfo ** __restrict  __pai ) ;
extern  __attribute__((__nothrow__)) void freeaddrinfo(struct addrinfo *__ai ) ;
extern  __attribute__((__nothrow__)) char const   *gai_strerror(int __ecode ) ;
extern int getnameinfo(struct sockaddr  const  * __restrict  __sa , socklen_t __salen , char * __restrict  __host , socklen_t __hostlen , char * __restrict  __serv , socklen_t __servlen , unsigned int __flags ) ;
extern int getaddrinfo_a(int __mode , struct gaicb ** __restrict  __list , int __ent , struct sigevent * __restrict  __sig ) ;
extern int gai_suspend(struct gaicb  const  * const  *__list , int __ent , struct timespec  const  *__timeout ) ;
extern  __attribute__((__nothrow__)) int gai_error(struct gaicb *__req ) ;
extern  __attribute__((__nothrow__)) int gai_cancel(struct gaicb *__gaicbp ) ;
extern  __attribute__((__nothrow__)) in_addr_t inet_addr(char const   *__cp ) ;
extern  __attribute__((__nothrow__)) in_addr_t inet_lnaof(struct in_addr __in ) ;
extern  __attribute__((__nothrow__)) struct in_addr inet_makeaddr(in_addr_t __net , in_addr_t __host ) ;
extern  __attribute__((__nothrow__)) in_addr_t inet_netof(struct in_addr __in ) ;
extern  __attribute__((__nothrow__)) in_addr_t inet_network(char const   *__cp ) ;
extern  __attribute__((__nothrow__)) char *inet_ntoa(struct in_addr __in ) ;
extern  __attribute__((__nothrow__)) int inet_pton(int __af , char const   * __restrict  __cp , void * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) char const   *inet_ntop(int __af , void const   * __restrict  __cp , char * __restrict  __buf , socklen_t __len ) ;
extern  __attribute__((__nothrow__)) int inet_aton(char const   *__cp , struct in_addr *__inp ) ;
extern  __attribute__((__nothrow__)) char *inet_neta(in_addr_t __net , char *__buf , size_t __len ) ;
extern  __attribute__((__nothrow__)) char *inet_net_ntop(int __af , void const   *__cp , int __bits , char *__buf , size_t __len ) ;
extern  __attribute__((__nothrow__)) int inet_net_pton(int __af , char const   *__cp , void *__buf , size_t __len ) ;
extern  __attribute__((__nothrow__)) unsigned int inet_nsap_addr(char const   *__cp , unsigned char *__buf , int __len ) ;
extern  __attribute__((__nothrow__)) char *inet_nsap_ntoa(int __len , unsigned char const   *__cp , char *__buf ) ;
extern  __attribute__((__nothrow__)) char *setlocale(int __category , char const   *__locale ) ;
extern  __attribute__((__nothrow__)) struct lconv *localeconv(void) ;
extern  __attribute__((__nothrow__)) __locale_t newlocale(int __category_mask , char const   *__locale , __locale_t __base ) ;
extern  __attribute__((__nothrow__)) __locale_t duplocale(__locale_t __dataset ) ;
extern  __attribute__((__nothrow__)) void freelocale(__locale_t __dataset ) ;
extern  __attribute__((__nothrow__)) __locale_t uselocale(__locale_t __dataset ) ;
extern  __attribute__((__nothrow__)) void *mmap(void *__addr , size_t __len , int __prot , int __flags , int __fd , __off_t __offset ) ;
extern  __attribute__((__nothrow__)) void *mmap64(void *__addr , size_t __len , int __prot , int __flags , int __fd , __off64_t __offset ) ;
extern  __attribute__((__nothrow__)) int munmap(void *__addr , size_t __len ) ;
extern  __attribute__((__nothrow__)) int mprotect(void *__addr , size_t __len , int __prot ) ;
extern int msync(void *__addr , size_t __len , int __flags ) ;
extern  __attribute__((__nothrow__)) int madvise(void *__addr , size_t __len , int __advice ) ;
extern  __attribute__((__nothrow__)) int posix_madvise(void *__addr , size_t __len , int __advice ) ;
extern  __attribute__((__nothrow__)) int mlock(void const   *__addr , size_t __len ) ;
extern  __attribute__((__nothrow__)) int munlock(void const   *__addr , size_t __len ) ;
extern  __attribute__((__nothrow__)) int mlockall(int __flags ) ;
extern  __attribute__((__nothrow__)) int munlockall(void) ;
extern  __attribute__((__nothrow__)) int mincore(void *__start , size_t __len , unsigned char *__vec ) ;
extern  __attribute__((__nothrow__)) void *mremap(void *__addr , size_t __old_len , size_t __new_len , int __flags  , ...) ;
extern  __attribute__((__nothrow__)) int remap_file_pages(void *__start , size_t __size , int __prot , size_t __pgoff , int __flags ) ;
extern int shm_open(char const   *__name , int __oflag , mode_t __mode ) ;
extern int shm_unlink(char const   *__name ) ;
extern int php_startup_ticks(void) ;
extern void php_deactivate_ticks(void) ;
extern void php_shutdown_ticks(void) ;
extern void php_run_ticks(int count ) ;
extern void __attribute__((__visibility__("default")))  php_add_tick_function(void (*func)(int  ) ) ;
extern void __attribute__((__visibility__("default")))  php_remove_tick_function(void (*func)(int  ) ) ;
extern php_stream *php_stream_url_wrap_http(php_stream_wrapper *wrapper , char *path , char *mode , int options , char **opened_path , php_stream_context *context ) ;
extern php_stream *php_stream_url_wrap_ftp(php_stream_wrapper *wrapper , char *path , char *mode , int options , char **opened_path , php_stream_context *context ) ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_stream_http_wrapper ;
extern php_stream_wrapper __attribute__((__visibility__("default")))  php_stream_ftp_wrapper ;
extern php_stream_wrapper php_stream_php_wrapper ;
extern void zif_stream_socket_client(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_server(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_accept(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_get_name(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_recvfrom(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_sendto(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_copy_to_stream(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_get_contents(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_set_blocking(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_select(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_set_timeout(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_set_read_buffer(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_set_write_buffer(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_set_chunk_size(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_get_transports(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_get_wrappers(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_get_line(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_get_meta_data(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_wrapper_register(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_wrapper_unregister(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_wrapper_restore(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_create(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_set_params(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_get_params(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_set_option(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_get_options(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_get_default(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_context_set_default(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_filter_prepend(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_filter_append(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_filter_remove(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_enable_crypto(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_shutdown(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_resolve_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_is_local(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_supports_lock(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
extern void zif_stream_socket_pair(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) ;
static zend_class_entry *incomplete_class_entry  =    (zend_class_entry *)((void *)0);
static void user_shutdown_function_dtor(php_shutdown_function_entry *shutdown_function_entry ) ;
static void user_tick_function_dtor(user_tick_function_entry *tick_function_entry ) ;
static HashTable basic_submodules  ;
static zend_arg_info const   arginfo_set_time_limit[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"seconds", sizeof("seconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_header_register_callback[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback", sizeof("callback") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ob_start[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"user_function", sizeof("user_function") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"chunk_size", sizeof("chunk_size") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ob_flush[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_ob_clean[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_ob_end_flush[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_ob_end_clean[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_ob_get_flush[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_ob_get_clean[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_ob_get_contents[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_ob_get_level[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_ob_get_length[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_ob_list_handlers[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_ob_get_status[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"full_status", sizeof("full_status") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ob_implicit_flush[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flag", sizeof("flag") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_output_reset_rewrite_vars[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_output_add_rewrite_var[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_wrapper_register[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"protocol", sizeof("protocol") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"classname", sizeof("classname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_wrapper_unregister[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"protocol", sizeof("protocol") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_wrapper_restore[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"protocol", sizeof("protocol") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_krsort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"sort_flags", sizeof("sort_flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ksort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"sort_flags", sizeof("sort_flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_count[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_natsort[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_natcasesort[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_asort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"sort_flags", sizeof("sort_flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_arsort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"sort_flags", sizeof("sort_flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"sort_flags", sizeof("sort_flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rsort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"sort_flags", sizeof("sort_flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_usort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"cmp_function", sizeof("cmp_function") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_uasort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"cmp_function", sizeof("cmp_function") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_uksort[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"cmp_function", sizeof("cmp_function") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_end[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_prev[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_next[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_reset[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_current[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}};
static zend_arg_info const   arginfo_key[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}};
static zend_arg_info const   arginfo_min[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg1", sizeof("arg1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg2", sizeof("arg2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_max[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg1", sizeof("arg1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg2", sizeof("arg2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_walk[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"funcname", sizeof("funcname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"userdata", sizeof("userdata") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_walk_recursive[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"funcname", sizeof("funcname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"userdata", sizeof("userdata") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_in_array[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"strict", sizeof("strict") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_search[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"strict", sizeof("strict") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_extract[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"extract_type", sizeof("extract_type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"prefix", sizeof("prefix") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_compact[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var_names", sizeof("var_names") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_fill[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"start_key", sizeof("start_key") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"num", sizeof("num") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"val", sizeof("val") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_fill_keys[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"keys", sizeof("keys") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"val", sizeof("val") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_range[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"low", sizeof("low") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"high", sizeof("high") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"step", sizeof("step") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_shuffle[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_array_push[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stack", sizeof("stack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_pop[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stack", sizeof("stack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_array_shift[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stack", sizeof("stack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_array_unshift[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stack", sizeof("stack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_splice[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replacement", sizeof("replacement") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_slice[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"preserve_keys", sizeof("preserve_keys") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_merge[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_merge_recursive[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_replace[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_replace_recursive[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_keys[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"search_value", sizeof("search_value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"strict", sizeof("strict") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_values[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_count_values[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_reverse[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"preserve_keys", sizeof("preserve_keys") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_pad[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pad_size", sizeof("pad_size") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pad_value", sizeof("pad_value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_flip[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_change_key_case[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"case", sizeof("case") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_unique[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_intersect_key[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_intersect_ukey[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_key_compare_func", sizeof("callback_key_compare_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_intersect[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_uintersect[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_data_compare_func", sizeof("callback_data_compare_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_intersect_assoc[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_uintersect_assoc[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_data_compare_func", sizeof("callback_data_compare_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_intersect_uassoc[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_key_compare_func", sizeof("callback_key_compare_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_uintersect_uassoc[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_data_compare_func", sizeof("callback_data_compare_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_key_compare_func", sizeof("callback_key_compare_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_diff_key[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_diff_ukey[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_key_comp_func", sizeof("callback_key_comp_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_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}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_udiff[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_data_comp_func", sizeof("callback_data_comp_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_diff_assoc[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_diff_uassoc[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_data_comp_func", sizeof("callback_data_comp_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_udiff_assoc[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_key_comp_func", sizeof("callback_key_comp_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_udiff_uassoc[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_data_comp_func", sizeof("callback_data_comp_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback_key_comp_func", sizeof("callback_key_comp_func") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_multisort[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"arr1", sizeof("arr1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"SORT_ASC_or_SORT_DESC", sizeof("SORT_ASC_or_SORT_DESC") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"SORT_REGULAR_or_SORT_NUMERIC_or_SORT_STRING", sizeof("SORT_REGULAR_or_SORT_NUMERIC_or_SORT_STRING") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"arr2", sizeof("arr2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"SORT_ASC_or_SORT_DESC", sizeof("SORT_ASC_or_SORT_DESC") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}, 
        {"SORT_REGULAR_or_SORT_NUMERIC_or_SORT_STRING", sizeof("SORT_REGULAR_or_SORT_NUMERIC_or_SORT_STRING") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )2}};
static zend_arg_info const   arginfo_array_rand[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"num_req", sizeof("num_req") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_sum[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_product[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_reduce[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback", sizeof("callback") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"initial", sizeof("initial") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_filter[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback", sizeof("callback") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_map[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callback", sizeof("callback") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_key_exists[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"key", sizeof("key") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"search", sizeof("search") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_chunk[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"size", sizeof("size") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"preserve_keys", sizeof("preserve_keys") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_array_combine[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"keys", sizeof("keys") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"values", sizeof("values") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_get_magic_quotes_gpc[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_get_magic_quotes_runtime[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_set_magic_quotes_runtime[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"new_setting", sizeof("new_setting") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_constant[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"const_name", sizeof("const_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_inet_ntop[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"in_addr", sizeof("in_addr") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_inet_pton[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ip_address", sizeof("ip_address") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ip2long[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ip_address", sizeof("ip_address") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_long2ip[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"proper_address", sizeof("proper_address") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getenv[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"varname", sizeof("varname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_putenv[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"setting", sizeof("setting") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getopt[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"opts", sizeof("opts") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_flush[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_sleep[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"seconds", sizeof("seconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_usleep[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"micro_seconds", sizeof("micro_seconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_time_nanosleep[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"seconds", sizeof("seconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"nanoseconds", sizeof("nanoseconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_time_sleep_until[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (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_get_current_user[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_get_cfg_var[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"option_name", sizeof("option_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_error_log[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"message", sizeof("message") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"message_type", sizeof("message_type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"destination", sizeof("destination") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"extra_headers", sizeof("extra_headers") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_error_get_last[1]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_call_user_func[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"parmeter", sizeof("parmeter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_call_user_func_array[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"parameters", sizeof("parameters") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_call_user_method[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"method_name", sizeof("method_name") - 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 )1}, 
        {"parameter", sizeof("parameter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_call_user_method_array[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"method_name", sizeof("method_name") - 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 )1}, 
        {"params", sizeof("params") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_forward_static_call[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"parameter", sizeof("parameter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_forward_static_call_array[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"parameters", sizeof("parameters") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_register_shutdown_function[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_highlight_file[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"file_name", sizeof("file_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return", sizeof("return") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_php_strip_whitespace[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"file_name", sizeof("file_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_highlight_string[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"string", sizeof("string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return", sizeof("return") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ini_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}, 
        {"varname", sizeof("varname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ini_get_all[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"extension", sizeof("extension") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ini_set[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"varname", sizeof("varname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"newvalue", sizeof("newvalue") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ini_restore[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"varname", sizeof("varname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_set_include_path[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"new_include_path", sizeof("new_include_path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_get_include_path[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_restore_include_path[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_print_r[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return", sizeof("return") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_connection_aborted[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_connection_status[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_ignore_user_abort[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getservbyname[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"service", sizeof("service") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"protocol", sizeof("protocol") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getservbyport[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"port", sizeof("port") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"protocol", sizeof("protocol") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getprotobyname[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getprotobynumber[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"proto", sizeof("proto") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_register_tick_function[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_unregister_tick_function[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"function_name", sizeof("function_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_uploaded_file[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_move_uploaded_file[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"new_path", sizeof("new_path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_parse_ini_file[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"process_sections", sizeof("process_sections") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"scanner_mode", sizeof("scanner_mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_parse_ini_string[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ini_string", sizeof("ini_string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"process_sections", sizeof("process_sections") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"scanner_mode", sizeof("scanner_mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sys_getloadavg[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_assert[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"assertion", sizeof("assertion") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_assert_options[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (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}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_base64_encode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_base64_decode[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"strict", sizeof("strict") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_get_browser[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"browser_name", sizeof("browser_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return_array", sizeof("return_array") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_crc32[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_crypt[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"salt", sizeof("salt") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_convert_cyr_string[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"from", sizeof("from") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"to", sizeof("to") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strptime[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", sizeof("timestamp") - 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_opendir[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dir[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"directory", sizeof("directory") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_closedir[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dir_handle", sizeof("dir_handle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_chdir[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"directory", sizeof("directory") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getcwd[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_rewinddir[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dir_handle", sizeof("dir_handle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_readdir[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dir_handle", sizeof("dir_handle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_glob[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pattern", sizeof("pattern") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_scandir[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dir", sizeof("dir") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"sorting_order", sizeof("sorting_order") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dl[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"extension_filename", sizeof("extension_filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gethostbyaddr[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ip_address", sizeof("ip_address") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gethostbyname[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hostname", sizeof("hostname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gethostbynamel[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hostname", sizeof("hostname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gethostname[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_dns_check_record[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"host", sizeof("host") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"type", sizeof("type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dns_get_record[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hostname", sizeof("hostname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"type", sizeof("type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"authns", sizeof("authns") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )4, (zend_bool )1, (zend_bool )1}, 
        {"addtl", sizeof("addtl") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )4, (zend_bool )1, (zend_bool )1}, 
        {"raw", sizeof("raw") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dns_get_mx[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hostname", sizeof("hostname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mxhosts", sizeof("mxhosts") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"weight", sizeof("weight") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_exec[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"command", sizeof("command") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"output", sizeof("output") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"return_value", sizeof("return_value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_system[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"command", sizeof("command") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return_value", sizeof("return_value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_passthru[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"command", sizeof("command") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return_value", sizeof("return_value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_escapeshellcmd[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"command", sizeof("command") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_escapeshellarg[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg", sizeof("arg") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_shell_exec[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"cmd", sizeof("cmd") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_proc_nice[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"priority", sizeof("priority") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_flock[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"operation", sizeof("operation") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"wouldblock", sizeof("wouldblock") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_get_meta_tags[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"use_include_path", sizeof("use_include_path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_file_get_contents[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"maxlen", sizeof("maxlen") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_file_put_contents[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_file[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_tempnam[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dir", sizeof("dir") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"prefix", sizeof("prefix") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_tmpfile[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_fopen[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"use_include_path", sizeof("use_include_path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fclose[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_popen[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"command", sizeof("command") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_pclose[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_feof[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fgets[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fgetc[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fgetss[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"allowable_tags", sizeof("allowable_tags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fscanf[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"stream", sizeof("stream") - 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}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_fwrite[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fflush[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rewind[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ftell[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fseek[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"whence", sizeof("whence") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_mkdir[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pathname", sizeof("pathname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"recursive", sizeof("recursive") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rmdir[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dirname", sizeof("dirname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_readfile[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_umask[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mask", sizeof("mask") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fpassthru[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rename[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"old_name", sizeof("old_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"new_name", sizeof("new_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_unlink[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ftruncate[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"size", sizeof("size") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fstat[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_copy[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source_file", sizeof("source_file") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"destination_file", sizeof("destination_file") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fread[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fputcsv[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fields", sizeof("fields") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"delimiter", sizeof("delimiter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"enclosure", sizeof("enclosure") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fgetcsv[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"delimiter", sizeof("delimiter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"enclosure", sizeof("enclosure") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"escape", sizeof("escape") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_realpath[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fnmatch[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pattern", sizeof("pattern") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sys_get_temp_dir[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_disk_total_space[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_disk_free_space[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_chgrp[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"group", sizeof("group") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_chown[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"user", sizeof("user") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_lchgrp[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"group", sizeof("group") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_lchown[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"user", sizeof("user") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_chmod[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_touch[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"time", sizeof("time") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"atime", sizeof("atime") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_clearstatcache[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"clear_realpath_cache", sizeof("clear_realpath_cache") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_realpath_cache_size[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_realpath_cache_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_fileperms[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fileinode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_filesize[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fileowner[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_filegroup[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fileatime[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_filemtime[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_filectime[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_filetype[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_writable[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_readable[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_executable[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_file[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_dir[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_link[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_file_exists[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_lstat[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stat[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sprintf[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}, 
        {"arg1", sizeof("arg1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_vsprintf[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}, 
        {"args", sizeof("args") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_printf[4]  = {      {(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}, 
        {"arg1", sizeof("arg1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_vprintf[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}, 
        {"args", sizeof("args") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fprintf[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 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}, 
        {"arg1", sizeof("arg1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_vfprintf[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 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}, 
        {"args", sizeof("args") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fsockopen[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hostname", sizeof("hostname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"port", sizeof("port") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"errno", sizeof("errno") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"errstr", sizeof("errstr") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"timeout", sizeof("timeout") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_pfsockopen[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hostname", sizeof("hostname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"port", sizeof("port") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"errno", sizeof("errno") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"errstr", sizeof("errstr") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"timeout", sizeof("timeout") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ftok[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pathname", sizeof("pathname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"proj", sizeof("proj") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_header[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"header", sizeof("header") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replace", sizeof("replace") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"http_response_code", sizeof("http_response_code") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_header_remove[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_setcookie[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"expires", sizeof("expires") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"domain", sizeof("domain") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"secure", sizeof("secure") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_setrawcookie[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"name", sizeof("name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"expires", sizeof("expires") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"domain", sizeof("domain") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"secure", sizeof("secure") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_headers_sent[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"file", sizeof("file") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"line", sizeof("line") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_headers_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_http_response_code[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"response_code", sizeof("response_code") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_htmlspecialchars[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"string", sizeof("string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"quote_style", sizeof("quote_style") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"charset", sizeof("charset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"double_encode", sizeof("double_encode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_htmlspecialchars_decode[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"string", sizeof("string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"quote_style", sizeof("quote_style") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_html_entity_decode[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"string", sizeof("string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"quote_style", sizeof("quote_style") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"charset", sizeof("charset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_htmlentities[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"string", sizeof("string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"quote_style", sizeof("quote_style") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"charset", sizeof("charset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"double_encode", sizeof("double_encode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_get_html_translation_table[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"table", sizeof("table") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"quote_style", sizeof("quote_style") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_http_build_query[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"formdata", sizeof("formdata") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"prefix", sizeof("prefix") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"arg_separator", sizeof("arg_separator") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"enc_type", sizeof("enc_type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_image_type_to_mime_type[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"imagetype", sizeof("imagetype") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_image_type_to_extension[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"imagetype", sizeof("imagetype") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"include_dot", sizeof("include_dot") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getimagesize[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"imagefile", sizeof("imagefile") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"info", sizeof("info") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_phpinfo[2]  = {      {(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}};
static zend_arg_info const   arginfo_phpversion[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"extension", sizeof("extension") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_phpcredits[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flag", sizeof("flag") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_php_logo_guid[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_php_real_logo_guid[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_php_egg_logo_guid[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_zend_logo_guid[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_php_sapi_name[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_php_uname[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_php_ini_scanned_files[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_php_ini_loaded_file[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_iptcembed[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"iptcdata", sizeof("iptcdata") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"jpeg_file_name", sizeof("jpeg_file_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"spool", sizeof("spool") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_iptcparse[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"iptcdata", sizeof("iptcdata") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_lcg_value[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_levenshtein[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str1", sizeof("str1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str2", sizeof("str2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"cost_ins", sizeof("cost_ins") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"cost_rep", sizeof("cost_rep") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"cost_del", sizeof("cost_del") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_readlink[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_linkinfo[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_symlink[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"target", sizeof("target") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"link", sizeof("link") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_link[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"target", sizeof("target") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"link", sizeof("link") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ezmlm_hash[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"addr", sizeof("addr") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_mail[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"to", sizeof("to") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"subject", sizeof("subject") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"message", sizeof("message") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"additional_headers", sizeof("additional_headers") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"additional_parameters", sizeof("additional_parameters") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_abs[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ceil[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_floor[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_round[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"precision", sizeof("precision") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sin[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_cos[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_tan[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_asin[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_acos[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_atan[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_atan2[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"y", sizeof("y") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"x", sizeof("x") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sinh[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_cosh[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_tanh[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_asinh[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_acosh[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_atanh[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_pi[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_is_finite[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"val", sizeof("val") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_infinite[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"val", sizeof("val") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_nan[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"val", sizeof("val") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_pow[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"base", sizeof("base") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"exponent", sizeof("exponent") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_exp[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_expm1[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_log1p[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_log[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"base", sizeof("base") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_log10[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sqrt[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_hypot[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"num1", sizeof("num1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"num2", sizeof("num2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_deg2rad[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rad2deg[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_bindec[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"binary_number", sizeof("binary_number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_hexdec[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"hexadecimal_number", sizeof("hexadecimal_number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_octdec[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"octal_number", sizeof("octal_number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_decbin[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"decimal_number", sizeof("decimal_number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_decoct[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"decimal_number", sizeof("decimal_number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dechex[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"decimal_number", sizeof("decimal_number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_base_convert[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"frombase", sizeof("frombase") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"tobase", sizeof("tobase") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_number_format[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"number", sizeof("number") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"num_decimal_places", sizeof("num_decimal_places") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dec_seperator", sizeof("dec_seperator") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"thousands_seperator", sizeof("thousands_seperator") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_fmod[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"x", sizeof("x") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"y", sizeof("y") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_md5[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"raw_output", sizeof("raw_output") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_md5_file[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"raw_output", sizeof("raw_output") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_metaphone[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"text", sizeof("text") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"phones", sizeof("phones") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_microtime[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"get_as_float", sizeof("get_as_float") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gettimeofday[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"get_as_float", sizeof("get_as_float") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getrusage[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"who", sizeof("who") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_pack[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}, 
        {"arg1", sizeof("arg1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_unpack[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}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getmyuid[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_getmygid[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_getmypid[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_getmyinode[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_getlastmod[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_proc_terminate[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"process", sizeof("process") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"signal", sizeof("signal") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_proc_close[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"process", sizeof("process") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_proc_get_status[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"process", sizeof("process") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_proc_open[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"command", sizeof("command") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"descriptorspec", sizeof("descriptorspec") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pipes", sizeof("pipes") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"cwd", sizeof("cwd") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"env", sizeof("env") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"other_options", sizeof("other_options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_quoted_printable_decode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_quoted_printable_encode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_srand[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"seed", sizeof("seed") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_mt_srand[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"seed", sizeof("seed") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rand[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (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}, 
        {"max", sizeof("max") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_mt_rand[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (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}, 
        {"max", sizeof("max") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_getrandmax[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_mt_getrandmax[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_sha1[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"raw_output", sizeof("raw_output") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sha1_file[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"raw_output", sizeof("raw_output") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_soundex[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_pair[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"domain", sizeof("domain") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"type", sizeof("type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"protocol", sizeof("protocol") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_client[7]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"remoteaddress", sizeof("remoteaddress") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"errcode", sizeof("errcode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"errstring", sizeof("errstring") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"timeout", sizeof("timeout") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_server[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"localaddress", sizeof("localaddress") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"errcode", sizeof("errcode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"errstring", sizeof("errstring") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"context", sizeof("context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_accept[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"serverstream", sizeof("serverstream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"timeout", sizeof("timeout") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"peername", sizeof("peername") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_stream_socket_get_name[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"want_peer", sizeof("want_peer") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_sendto[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"target_addr", sizeof("target_addr") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_recvfrom[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"amount", sizeof("amount") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"flags", sizeof("flags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"remote_addr", sizeof("remote_addr") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_stream_get_contents[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"maxlen", sizeof("maxlen") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_copy_to_stream[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"source", sizeof("source") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"dest", sizeof("dest") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"maxlen", sizeof("maxlen") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pos", sizeof("pos") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_get_meta_data[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_get_transports[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_stream_get_wrappers[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_stream_resolve_include_path[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filename", sizeof("filename") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_is_local[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_supports_lock[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_select[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )4, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"read_streams", sizeof("read_streams") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"write_streams", sizeof("write_streams") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"except_streams", sizeof("except_streams") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"tv_sec", sizeof("tv_sec") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"tv_usec", sizeof("tv_usec") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_get_options[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream_or_context", sizeof("stream_or_context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_set_option[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream_or_context", sizeof("stream_or_context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"wrappername", sizeof("wrappername") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"optionname", sizeof("optionname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_set_params[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream_or_context", sizeof("stream_or_context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_get_params[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream_or_context", sizeof("stream_or_context") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_get_default[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_set_default[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_context_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}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"params", sizeof("params") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_filter_prepend[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filtername", sizeof("filtername") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"read_write", sizeof("read_write") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filterparams", sizeof("filterparams") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_filter_append[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filtername", sizeof("filtername") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"read_write", sizeof("read_write") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filterparams", sizeof("filterparams") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_filter_remove[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream_filter", sizeof("stream_filter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_get_line[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"maxlen", sizeof("maxlen") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ending", sizeof("ending") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_set_blocking[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"socket", sizeof("socket") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_set_timeout[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"seconds", sizeof("seconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"microseconds", sizeof("microseconds") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_set_read_buffer[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"buffer", sizeof("buffer") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_set_write_buffer[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"buffer", sizeof("buffer") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_set_chunk_size[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"fp", sizeof("fp") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"chunk_size", sizeof("chunk_size") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_enable_crypto[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"enable", sizeof("enable") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"cryptokind", sizeof("cryptokind") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"sessionstream", sizeof("sessionstream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_socket_shutdown[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"how", sizeof("how") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_bin2hex[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_hex2bin[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strspn[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mask", sizeof("mask") - 1U, (char const   *)((void *)0), (zend_uint )0, (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}, 
        {"len", sizeof("len") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strcspn[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mask", sizeof("mask") - 1U, (char const   *)((void *)0), (zend_uint )0, (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}, 
        {"len", sizeof("len") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_nl_langinfo[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"item", sizeof("item") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strcoll[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str1", sizeof("str1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str2", sizeof("str2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_trim[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"character_mask", sizeof("character_mask") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rtrim[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"character_mask", sizeof("character_mask") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ltrim[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"character_mask", sizeof("character_mask") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_wordwrap[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"width", sizeof("width") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"break", sizeof("break") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"cut", sizeof("cut") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_explode[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"separator", sizeof("separator") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"limit", sizeof("limit") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_implode[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"glue", sizeof("glue") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pieces", sizeof("pieces") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strtok[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"token", sizeof("token") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strtoupper[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strtolower[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_basename[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"suffix", sizeof("suffix") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_dirname[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_pathinfo[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"path", sizeof("path") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"options", sizeof("options") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stristr[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"part", sizeof("part") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strstr[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"part", sizeof("part") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strpos[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stripos[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strrpos[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strripos[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strrchr[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_chunk_split[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"chunklen", sizeof("chunklen") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ending", sizeof("ending") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_substr[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (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}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_substr_replace[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replace", sizeof("replace") - 1U, (char const   *)((void *)0), (zend_uint )0, (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}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_quotemeta[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ord[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"character", sizeof("character") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_chr[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"codepoint", sizeof("codepoint") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ucfirst[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_lcfirst[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_ucwords[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strtr[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"from", sizeof("from") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"to", sizeof("to") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strrev[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_similar_text[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str1", sizeof("str1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str2", sizeof("str2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"percent", sizeof("percent") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_addcslashes[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"charlist", sizeof("charlist") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_addslashes[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stripcslashes[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stripslashes[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_str_replace[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"search", sizeof("search") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replace", sizeof("replace") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"subject", sizeof("subject") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replace_count", sizeof("replace_count") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_str_ireplace[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"search", sizeof("search") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replace", sizeof("replace") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"subject", sizeof("subject") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"replace_count", sizeof("replace_count") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_hebrev[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"max_chars_per_line", sizeof("max_chars_per_line") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_hebrevc[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"max_chars_per_line", sizeof("max_chars_per_line") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_nl2br[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"is_xhtml", sizeof("is_xhtml") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strip_tags[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"allowable_tags", sizeof("allowable_tags") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_setlocale[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"category", sizeof("category") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"locale", sizeof("locale") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_parse_str[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"encoded_string", sizeof("encoded_string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"result", sizeof("result") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_str_getcsv[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"string", sizeof("string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"delimiter", sizeof("delimiter") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"enclosure", sizeof("enclosure") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"escape", sizeof("escape") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_str_repeat[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mult", sizeof("mult") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_count_chars[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"mode", sizeof("mode") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strnatcmp[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"s1", sizeof("s1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"s2", sizeof("s2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_localeconv[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_strnatcasecmp[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"s1", sizeof("s1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"s2", sizeof("s2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_substr_count[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"needle", sizeof("needle") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_str_pad[5]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"input", sizeof("input") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pad_length", sizeof("pad_length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pad_string", sizeof("pad_string") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"pad_type", sizeof("pad_type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_sscanf[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"str", sizeof("str") - 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}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_str_rot13[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_str_shuffle[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_str_word_count[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 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}, 
        {"charlist", sizeof("charlist") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_money_format[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}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_str_split[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"split_length", sizeof("split_length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strpbrk[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"haystack", sizeof("haystack") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"char_list", sizeof("char_list") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_substr_compare[6]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )3, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"main_str", sizeof("main_str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"offset", sizeof("offset") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"length", sizeof("length") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"case_sensitivity", sizeof("case_sensitivity") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_openlog[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ident", sizeof("ident") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"option", sizeof("option") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"facility", sizeof("facility") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_closelog[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_syslog[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"priority", sizeof("priority") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"message", sizeof("message") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_gettype[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_settype[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}, 
        {"type", sizeof("type") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_intval[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"base", sizeof("base") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_floatval[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_strval[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_null[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_resource[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_bool[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_long[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_float[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_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}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_array[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_object[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_numeric[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_scalar[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"value", sizeof("value") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_is_callable[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"syntax_only", sizeof("syntax_only") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"callable_name", sizeof("callable_name") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )1}};
static zend_arg_info const   arginfo_uniqid[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"prefix", sizeof("prefix") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"more_entropy", sizeof("more_entropy") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_parse_url[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"url", sizeof("url") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"component", sizeof("component") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_urlencode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_urldecode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rawurlencode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_rawurldecode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"str", sizeof("str") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_get_headers[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"url", sizeof("url") - 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_stream_bucket_make_writeable[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"brigade", sizeof("brigade") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_bucket_prepend[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"brigade", sizeof("brigade") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"bucket", sizeof("bucket") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_bucket_append[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"brigade", sizeof("brigade") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"bucket", sizeof("bucket") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_bucket_new[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"stream", sizeof("stream") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"buffer", sizeof("buffer") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_stream_get_filters[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_stream_filter_register[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"filtername", sizeof("filtername") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"classname", sizeof("classname") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_convert_uuencode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_convert_uudecode[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"data", sizeof("data") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_var_dump[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_debug_zval_dump[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"...", sizeof("...") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_var_export[3]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"return", sizeof("return") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_serialize[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"var", sizeof("var") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_unserialize[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )-1, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"variable_representation", sizeof("variable_representation") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_memory_get_usage[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"real_usage", sizeof("real_usage") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_memory_get_peak_usage[2]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"real_usage", sizeof("real_usage") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
static zend_arg_info const   arginfo_version_compare[4]  = {      {(char const   *)((void *)0), (zend_uint )0, (char const   *)((void *)0), (zend_uint )2, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ver1", sizeof("ver1") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"ver2", sizeof("ver2") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}, 
        {"oper", sizeof("oper") - 1U, (char const   *)((void *)0), (zend_uint )0, (zend_uchar )0, (zend_bool )0, (zend_bool )0}};
zend_function_entry const   basic_functions[526]  = 
  {      {"constant", & zif_constant, arginfo_constant, sizeof(arginfo_constant) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"bin2hex", & zif_bin2hex, arginfo_bin2hex, sizeof(arginfo_bin2hex) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"hex2bin", & zif_hex2bin, arginfo_hex2bin, sizeof(arginfo_hex2bin) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sleep", & zif_sleep, arginfo_sleep, sizeof(arginfo_sleep) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"usleep", & zif_usleep, arginfo_usleep, sizeof(arginfo_usleep) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"time_nanosleep", & zif_time_nanosleep, arginfo_time_nanosleep, sizeof(arginfo_time_nanosleep) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"time_sleep_until", & zif_time_sleep_until, arginfo_time_sleep_until, sizeof(arginfo_time_sleep_until) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strptime", & zif_strptime, arginfo_strptime, sizeof(arginfo_strptime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"flush", & zif_flush, arginfo_flush, sizeof(arginfo_flush) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"wordwrap", & zif_wordwrap, arginfo_wordwrap, sizeof(arginfo_wordwrap) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"htmlspecialchars", & zif_htmlspecialchars, arginfo_htmlspecialchars, sizeof(arginfo_htmlspecialchars) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"htmlentities", & zif_htmlentities, arginfo_htmlentities, sizeof(arginfo_htmlentities) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"html_entity_decode", & zif_html_entity_decode, arginfo_html_entity_decode, sizeof(arginfo_html_entity_decode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"htmlspecialchars_decode", & zif_htmlspecialchars_decode, arginfo_htmlspecialchars_decode, sizeof(arginfo_htmlspecialchars_decode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_html_translation_table", & zif_get_html_translation_table, arginfo_get_html_translation_table, sizeof(arginfo_get_html_translation_table) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sha1", & zif_sha1, arginfo_sha1, sizeof(arginfo_sha1) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sha1_file", & zif_sha1_file, arginfo_sha1_file, sizeof(arginfo_sha1_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"md5", & php_if_md5, arginfo_md5, sizeof(arginfo_md5) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"md5_file", & php_if_md5_file, arginfo_md5_file, sizeof(arginfo_md5_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"crc32", & php_if_crc32, arginfo_crc32, sizeof(arginfo_crc32) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"iptcparse", & zif_iptcparse, arginfo_iptcparse, sizeof(arginfo_iptcparse) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"iptcembed", & zif_iptcembed, arginfo_iptcembed, sizeof(arginfo_iptcembed) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getimagesize", & zif_getimagesize, arginfo_getimagesize, sizeof(arginfo_getimagesize) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getimagesizefromstring", & zif_getimagesizefromstring, arginfo_getimagesize, sizeof(arginfo_getimagesize) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"image_type_to_mime_type", & zif_image_type_to_mime_type, arginfo_image_type_to_mime_type, sizeof(arginfo_image_type_to_mime_type) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"image_type_to_extension", & zif_image_type_to_extension, arginfo_image_type_to_extension, sizeof(arginfo_image_type_to_extension) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"phpinfo", & zif_phpinfo, arginfo_phpinfo, sizeof(arginfo_phpinfo) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"phpversion", & zif_phpversion, arginfo_phpversion, sizeof(arginfo_phpversion) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"phpcredits", & zif_phpcredits, arginfo_phpcredits, sizeof(arginfo_phpcredits) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_logo_guid", & zif_php_logo_guid, arginfo_php_logo_guid, sizeof(arginfo_php_logo_guid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_real_logo_guid", & zif_php_real_logo_guid, arginfo_php_real_logo_guid, sizeof(arginfo_php_real_logo_guid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_egg_logo_guid", & zif_php_egg_logo_guid, arginfo_php_egg_logo_guid, sizeof(arginfo_php_egg_logo_guid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"zend_logo_guid", & zif_zend_logo_guid, arginfo_zend_logo_guid, sizeof(arginfo_zend_logo_guid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_sapi_name", & zif_php_sapi_name, arginfo_php_sapi_name, sizeof(arginfo_php_sapi_name) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_uname", & zif_php_uname, arginfo_php_uname, sizeof(arginfo_php_uname) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_ini_scanned_files", & zif_php_ini_scanned_files, arginfo_php_ini_scanned_files, sizeof(arginfo_php_ini_scanned_files) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_ini_loaded_file", & zif_php_ini_loaded_file, arginfo_php_ini_loaded_file, sizeof(arginfo_php_ini_loaded_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strnatcmp", & zif_strnatcmp, arginfo_strnatcmp, sizeof(arginfo_strnatcmp) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strnatcasecmp", & zif_strnatcasecmp, arginfo_strnatcasecmp, sizeof(arginfo_strnatcasecmp) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"substr_count", & zif_substr_count, arginfo_substr_count, sizeof(arginfo_substr_count) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strspn", & zif_strspn, arginfo_strspn, sizeof(arginfo_strspn) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strcspn", & zif_strcspn, arginfo_strcspn, sizeof(arginfo_strcspn) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strtok", & zif_strtok, arginfo_strtok, sizeof(arginfo_strtok) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strtoupper", & zif_strtoupper, arginfo_strtoupper, sizeof(arginfo_strtoupper) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strtolower", & zif_strtolower, arginfo_strtolower, sizeof(arginfo_strtolower) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strpos", & zif_strpos, arginfo_strpos, sizeof(arginfo_strpos) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stripos", & zif_stripos, arginfo_stripos, sizeof(arginfo_stripos) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strrpos", & zif_strrpos, arginfo_strrpos, sizeof(arginfo_strrpos) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strripos", & zif_strripos, arginfo_strripos, sizeof(arginfo_strripos) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strrev", & zif_strrev, arginfo_strrev, sizeof(arginfo_strrev) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"hebrev", & zif_hebrev, arginfo_hebrev, sizeof(arginfo_hebrev) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"hebrevc", & zif_hebrevc, arginfo_hebrevc, sizeof(arginfo_hebrevc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"nl2br", & zif_nl2br, arginfo_nl2br, sizeof(arginfo_nl2br) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"basename", & zif_basename, arginfo_basename, sizeof(arginfo_basename) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"dirname", & zif_dirname, arginfo_dirname, sizeof(arginfo_dirname) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pathinfo", & zif_pathinfo, arginfo_pathinfo, sizeof(arginfo_pathinfo) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stripslashes", & zif_stripslashes, arginfo_stripslashes, sizeof(arginfo_stripslashes) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stripcslashes", & zif_stripcslashes, arginfo_stripcslashes, sizeof(arginfo_stripcslashes) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strstr", & zif_strstr, arginfo_strstr, sizeof(arginfo_strstr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stristr", & zif_stristr, arginfo_stristr, sizeof(arginfo_stristr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strrchr", & zif_strrchr, arginfo_strrchr, sizeof(arginfo_strrchr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_shuffle", & zif_str_shuffle, arginfo_str_shuffle, sizeof(arginfo_str_shuffle) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_word_count", & zif_str_word_count, arginfo_str_word_count, sizeof(arginfo_str_word_count) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_split", & zif_str_split, arginfo_str_split, sizeof(arginfo_str_split) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strpbrk", & zif_strpbrk, arginfo_strpbrk, sizeof(arginfo_strpbrk) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"substr_compare", & zif_substr_compare, arginfo_substr_compare, sizeof(arginfo_substr_compare) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strcoll", & zif_strcoll, arginfo_strcoll, sizeof(arginfo_strcoll) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"money_format", & zif_money_format, arginfo_money_format, sizeof(arginfo_money_format) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"substr", & zif_substr, arginfo_substr, sizeof(arginfo_substr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"substr_replace", & zif_substr_replace, arginfo_substr_replace, sizeof(arginfo_substr_replace) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"quotemeta", & zif_quotemeta, arginfo_quotemeta, sizeof(arginfo_quotemeta) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ucfirst", & zif_ucfirst, arginfo_ucfirst, sizeof(arginfo_ucfirst) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"lcfirst", & zif_lcfirst, arginfo_lcfirst, sizeof(arginfo_lcfirst) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ucwords", & zif_ucwords, arginfo_ucwords, sizeof(arginfo_ucwords) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strtr", & zif_strtr, arginfo_strtr, sizeof(arginfo_strtr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"addslashes", & zif_addslashes, arginfo_addslashes, sizeof(arginfo_addslashes) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"addcslashes", & zif_addcslashes, arginfo_addcslashes, sizeof(arginfo_addcslashes) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rtrim", & zif_rtrim, arginfo_rtrim, sizeof(arginfo_rtrim) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_replace", & zif_str_replace, arginfo_str_replace, sizeof(arginfo_str_replace) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_ireplace", & zif_str_ireplace, arginfo_str_ireplace, sizeof(arginfo_str_ireplace) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_repeat", & zif_str_repeat, arginfo_str_repeat, sizeof(arginfo_str_repeat) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"count_chars", & zif_count_chars, arginfo_count_chars, sizeof(arginfo_count_chars) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chunk_split", & zif_chunk_split, arginfo_chunk_split, sizeof(arginfo_chunk_split) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"trim", & zif_trim, arginfo_trim, sizeof(arginfo_trim) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ltrim", & zif_ltrim, arginfo_ltrim, sizeof(arginfo_ltrim) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strip_tags", & zif_strip_tags, arginfo_strip_tags, sizeof(arginfo_strip_tags) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"similar_text", & zif_similar_text, arginfo_similar_text, sizeof(arginfo_similar_text) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"explode", & zif_explode, arginfo_explode, sizeof(arginfo_explode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"implode", & zif_implode, arginfo_implode, sizeof(arginfo_implode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"join", & zif_implode, arginfo_implode, sizeof(arginfo_implode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"setlocale", & zif_setlocale, arginfo_setlocale, sizeof(arginfo_setlocale) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"localeconv", & zif_localeconv, arginfo_localeconv, sizeof(arginfo_localeconv) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"nl_langinfo", & zif_nl_langinfo, arginfo_nl_langinfo, sizeof(arginfo_nl_langinfo) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"soundex", & zif_soundex, arginfo_soundex, sizeof(arginfo_soundex) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"levenshtein", & zif_levenshtein, arginfo_levenshtein, sizeof(arginfo_levenshtein) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chr", & zif_chr, arginfo_chr, sizeof(arginfo_chr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ord", & zif_ord, arginfo_ord, sizeof(arginfo_ord) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"parse_str", & zif_parse_str, arginfo_parse_str, sizeof(arginfo_parse_str) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_getcsv", & zif_str_getcsv, arginfo_str_getcsv, sizeof(arginfo_str_getcsv) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_pad", & zif_str_pad, arginfo_str_pad, sizeof(arginfo_str_pad) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chop", & zif_rtrim, arginfo_rtrim, sizeof(arginfo_rtrim) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strchr", & zif_strstr, arginfo_strstr, sizeof(arginfo_strstr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sprintf", & zif_user_sprintf, arginfo_sprintf, sizeof(arginfo_sprintf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"printf", & zif_user_printf, arginfo_printf, sizeof(arginfo_printf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"vprintf", & zif_vprintf, arginfo_vprintf, sizeof(arginfo_vprintf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"vsprintf", & zif_vsprintf, arginfo_vsprintf, sizeof(arginfo_vsprintf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fprintf", & zif_fprintf, arginfo_fprintf, sizeof(arginfo_fprintf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"vfprintf", & zif_vfprintf, arginfo_vfprintf, sizeof(arginfo_vfprintf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sscanf", & zif_sscanf, arginfo_sscanf, sizeof(arginfo_sscanf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fscanf", & zif_fscanf, arginfo_fscanf, sizeof(arginfo_fscanf) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"parse_url", & zif_parse_url, arginfo_parse_url, sizeof(arginfo_parse_url) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"urlencode", & zif_urlencode, arginfo_urlencode, sizeof(arginfo_urlencode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"urldecode", & zif_urldecode, arginfo_urldecode, sizeof(arginfo_urldecode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rawurlencode", & zif_rawurlencode, arginfo_rawurlencode, sizeof(arginfo_rawurlencode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rawurldecode", & zif_rawurldecode, arginfo_rawurldecode, sizeof(arginfo_rawurldecode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"http_build_query", & zif_http_build_query, arginfo_http_build_query, sizeof(arginfo_http_build_query) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"readlink", & zif_readlink, arginfo_readlink, sizeof(arginfo_readlink) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"linkinfo", & zif_linkinfo, arginfo_linkinfo, sizeof(arginfo_linkinfo) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"symlink", & zif_symlink, arginfo_symlink, sizeof(arginfo_symlink) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"link", & zif_link, arginfo_link, sizeof(arginfo_link) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"unlink", & zif_unlink, arginfo_unlink, sizeof(arginfo_unlink) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"exec", & zif_exec, arginfo_exec, sizeof(arginfo_exec) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"system", & zif_system, arginfo_system, sizeof(arginfo_system) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"escapeshellcmd", & zif_escapeshellcmd, arginfo_escapeshellcmd, sizeof(arginfo_escapeshellcmd) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"escapeshellarg", & zif_escapeshellarg, arginfo_escapeshellarg, sizeof(arginfo_escapeshellarg) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"passthru", & zif_passthru, arginfo_passthru, sizeof(arginfo_passthru) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"shell_exec", & zif_shell_exec, arginfo_shell_exec, sizeof(arginfo_shell_exec) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"proc_open", & zif_proc_open, arginfo_proc_open, sizeof(arginfo_proc_open) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"proc_close", & zif_proc_close, arginfo_proc_close, sizeof(arginfo_proc_close) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"proc_terminate", & zif_proc_terminate, arginfo_proc_terminate, sizeof(arginfo_proc_terminate) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"proc_get_status", & zif_proc_get_status, arginfo_proc_get_status, sizeof(arginfo_proc_get_status) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"proc_nice", & zif_proc_nice, arginfo_proc_nice, sizeof(arginfo_proc_nice) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rand", & zif_rand, arginfo_rand, sizeof(arginfo_rand) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"srand", & zif_srand, arginfo_srand, sizeof(arginfo_srand) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getrandmax", & zif_getrandmax, arginfo_getrandmax, sizeof(arginfo_getrandmax) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"mt_rand", & zif_mt_rand, arginfo_mt_rand, sizeof(arginfo_mt_rand) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"mt_srand", & zif_mt_srand, arginfo_mt_srand, sizeof(arginfo_mt_srand) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"mt_getrandmax", & zif_mt_getrandmax, arginfo_mt_getrandmax, sizeof(arginfo_mt_getrandmax) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getservbyname", & zif_getservbyname, arginfo_getservbyname, sizeof(arginfo_getservbyname) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getservbyport", & zif_getservbyport, arginfo_getservbyport, sizeof(arginfo_getservbyport) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getprotobyname", & zif_getprotobyname, arginfo_getprotobyname, sizeof(arginfo_getprotobyname) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getprotobynumber", & zif_getprotobynumber, arginfo_getprotobynumber, sizeof(arginfo_getprotobynumber) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getmyuid", & zif_getmyuid, arginfo_getmyuid, sizeof(arginfo_getmyuid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getmygid", & zif_getmygid, arginfo_getmygid, sizeof(arginfo_getmygid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getmypid", & zif_getmypid, arginfo_getmypid, sizeof(arginfo_getmypid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getmyinode", & zif_getmyinode, arginfo_getmyinode, sizeof(arginfo_getmyinode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getlastmod", & zif_getlastmod, arginfo_getlastmod, sizeof(arginfo_getlastmod) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"base64_decode", & zif_base64_decode, arginfo_base64_decode, sizeof(arginfo_base64_decode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"base64_encode", & zif_base64_encode, arginfo_base64_encode, sizeof(arginfo_base64_encode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"convert_uuencode", & zif_convert_uuencode, arginfo_convert_uuencode, sizeof(arginfo_convert_uuencode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"convert_uudecode", & zif_convert_uudecode, arginfo_convert_uudecode, sizeof(arginfo_convert_uudecode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"abs", & zif_abs, arginfo_abs, sizeof(arginfo_abs) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ceil", & zif_ceil, arginfo_ceil, sizeof(arginfo_ceil) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"floor", & zif_floor, arginfo_floor, sizeof(arginfo_floor) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"round", & zif_round, arginfo_round, sizeof(arginfo_round) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sin", & zif_sin, arginfo_sin, sizeof(arginfo_sin) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"cos", & zif_cos, arginfo_cos, sizeof(arginfo_cos) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"tan", & zif_tan, arginfo_tan, sizeof(arginfo_tan) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"asin", & zif_asin, arginfo_asin, sizeof(arginfo_asin) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"acos", & zif_acos, arginfo_acos, sizeof(arginfo_acos) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"atan", & zif_atan, arginfo_atan, sizeof(arginfo_atan) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"atanh", & zif_atanh, arginfo_atanh, sizeof(arginfo_atanh) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"atan2", & zif_atan2, arginfo_atan2, sizeof(arginfo_atan2) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sinh", & zif_sinh, arginfo_sinh, sizeof(arginfo_sinh) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"cosh", & zif_cosh, arginfo_cosh, sizeof(arginfo_cosh) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"tanh", & zif_tanh, arginfo_tanh, sizeof(arginfo_tanh) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"asinh", & zif_asinh, arginfo_asinh, sizeof(arginfo_asinh) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"acosh", & zif_acosh, arginfo_acosh, sizeof(arginfo_acosh) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"expm1", & zif_expm1, arginfo_expm1, sizeof(arginfo_expm1) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"log1p", & zif_log1p, arginfo_log1p, sizeof(arginfo_log1p) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pi", & zif_pi, arginfo_pi, sizeof(arginfo_pi) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_finite", & zif_is_finite, arginfo_is_finite, sizeof(arginfo_is_finite) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_nan", & zif_is_nan, arginfo_is_nan, sizeof(arginfo_is_nan) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_infinite", & zif_is_infinite, arginfo_is_infinite, sizeof(arginfo_is_infinite) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pow", & zif_pow, arginfo_pow, sizeof(arginfo_pow) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"exp", & zif_exp, arginfo_exp, sizeof(arginfo_exp) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"log", & zif_log, arginfo_log, sizeof(arginfo_log) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"log10", & zif_log10, arginfo_log10, sizeof(arginfo_log10) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sqrt", & zif_sqrt, arginfo_sqrt, sizeof(arginfo_sqrt) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"hypot", & zif_hypot, arginfo_hypot, sizeof(arginfo_hypot) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"deg2rad", & zif_deg2rad, arginfo_deg2rad, sizeof(arginfo_deg2rad) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rad2deg", & zif_rad2deg, arginfo_rad2deg, sizeof(arginfo_rad2deg) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"bindec", & zif_bindec, arginfo_bindec, sizeof(arginfo_bindec) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"hexdec", & zif_hexdec, arginfo_hexdec, sizeof(arginfo_hexdec) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"octdec", & zif_octdec, arginfo_octdec, sizeof(arginfo_octdec) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"decbin", & zif_decbin, arginfo_decbin, sizeof(arginfo_decbin) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"decoct", & zif_decoct, arginfo_decoct, sizeof(arginfo_decoct) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"dechex", & zif_dechex, arginfo_dechex, sizeof(arginfo_dechex) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"base_convert", & zif_base_convert, arginfo_base_convert, sizeof(arginfo_base_convert) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"number_format", & zif_number_format, arginfo_number_format, sizeof(arginfo_number_format) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fmod", & zif_fmod, arginfo_fmod, sizeof(arginfo_fmod) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"inet_ntop", & php_inet_ntop, arginfo_inet_ntop, sizeof(arginfo_inet_ntop) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"inet_pton", & php_inet_pton, arginfo_inet_pton, sizeof(arginfo_inet_pton) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ip2long", & zif_ip2long, arginfo_ip2long, sizeof(arginfo_ip2long) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"long2ip", & zif_long2ip, arginfo_long2ip, sizeof(arginfo_long2ip) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getenv", & zif_getenv, arginfo_getenv, sizeof(arginfo_getenv) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"putenv", & zif_putenv, arginfo_putenv, sizeof(arginfo_putenv) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getopt", & zif_getopt, arginfo_getopt, sizeof(arginfo_getopt) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sys_getloadavg", & zif_sys_getloadavg, arginfo_sys_getloadavg, sizeof(arginfo_sys_getloadavg) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"microtime", & zif_microtime, arginfo_microtime, sizeof(arginfo_microtime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gettimeofday", & zif_gettimeofday, arginfo_gettimeofday, sizeof(arginfo_gettimeofday) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getrusage", & zif_getrusage, arginfo_getrusage, sizeof(arginfo_getrusage) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"uniqid", & zif_uniqid, arginfo_uniqid, sizeof(arginfo_uniqid) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"quoted_printable_decode", & zif_quoted_printable_decode, arginfo_quoted_printable_decode, sizeof(arginfo_quoted_printable_decode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"quoted_printable_encode", & zif_quoted_printable_encode, arginfo_quoted_printable_encode, sizeof(arginfo_quoted_printable_encode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"convert_cyr_string", & zif_convert_cyr_string, arginfo_convert_cyr_string, sizeof(arginfo_convert_cyr_string) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_current_user", & zif_get_current_user, arginfo_get_current_user, sizeof(arginfo_get_current_user) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"set_time_limit", & zif_set_time_limit, arginfo_set_time_limit, sizeof(arginfo_set_time_limit) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"header_register_callback", & zif_header_register_callback, arginfo_header_register_callback, sizeof(arginfo_header_register_callback) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_cfg_var", & zif_get_cfg_var, arginfo_get_cfg_var, sizeof(arginfo_get_cfg_var) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"magic_quotes_runtime", & zif_set_magic_quotes_runtime, arginfo_set_magic_quotes_runtime, sizeof(arginfo_set_magic_quotes_runtime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0x40000}, 
        {"set_magic_quotes_runtime", & zif_set_magic_quotes_runtime, arginfo_set_magic_quotes_runtime, sizeof(arginfo_set_magic_quotes_runtime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0x40000}, 
        {"get_magic_quotes_gpc", & zif_get_magic_quotes_gpc, arginfo_get_magic_quotes_gpc, sizeof(arginfo_get_magic_quotes_gpc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_magic_quotes_runtime", & zif_get_magic_quotes_runtime, arginfo_get_magic_quotes_runtime, sizeof(arginfo_get_magic_quotes_runtime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"error_log", & zif_error_log, arginfo_error_log, sizeof(arginfo_error_log) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"error_get_last", & zif_error_get_last, arginfo_error_get_last, sizeof(arginfo_error_get_last) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"call_user_func", & zif_call_user_func, arginfo_call_user_func, sizeof(arginfo_call_user_func) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"call_user_func_array", & zif_call_user_func_array, arginfo_call_user_func_array, sizeof(arginfo_call_user_func_array) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"call_user_method", & zif_call_user_method, arginfo_call_user_method, sizeof(arginfo_call_user_method) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0x40000}, 
        {"call_user_method_array", & zif_call_user_method_array, arginfo_call_user_method_array, sizeof(arginfo_call_user_method_array) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0x40000}, 
        {"forward_static_call", & zif_forward_static_call, arginfo_forward_static_call, sizeof(arginfo_forward_static_call) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"forward_static_call_array", & zif_forward_static_call_array, arginfo_forward_static_call_array, sizeof(arginfo_forward_static_call_array) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"serialize", & zif_serialize, arginfo_serialize, sizeof(arginfo_serialize) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"unserialize", & zif_unserialize, arginfo_unserialize, sizeof(arginfo_unserialize) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"var_dump", & zif_var_dump, arginfo_var_dump, sizeof(arginfo_var_dump) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"var_export", & zif_var_export, arginfo_var_export, sizeof(arginfo_var_export) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"debug_zval_dump", & zif_debug_zval_dump, arginfo_debug_zval_dump, sizeof(arginfo_debug_zval_dump) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"print_r", & zif_print_r, arginfo_print_r, sizeof(arginfo_print_r) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"memory_get_usage", & zif_memory_get_usage, arginfo_memory_get_usage, sizeof(arginfo_memory_get_usage) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"memory_get_peak_usage", & zif_memory_get_peak_usage, arginfo_memory_get_peak_usage, sizeof(arginfo_memory_get_peak_usage) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"register_shutdown_function", & zif_register_shutdown_function, arginfo_register_shutdown_function, sizeof(arginfo_register_shutdown_function) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"register_tick_function", & zif_register_tick_function, arginfo_register_tick_function, sizeof(arginfo_register_tick_function) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"unregister_tick_function", & zif_unregister_tick_function, arginfo_unregister_tick_function, sizeof(arginfo_unregister_tick_function) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"highlight_file", & zif_highlight_file, arginfo_highlight_file, sizeof(arginfo_highlight_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"show_source", & zif_highlight_file, arginfo_highlight_file, sizeof(arginfo_highlight_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"highlight_string", & zif_highlight_string, arginfo_highlight_string, sizeof(arginfo_highlight_string) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"php_strip_whitespace", & zif_php_strip_whitespace, arginfo_php_strip_whitespace, sizeof(arginfo_php_strip_whitespace) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ini_get", & zif_ini_get, arginfo_ini_get, sizeof(arginfo_ini_get) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ini_get_all", & zif_ini_get_all, arginfo_ini_get_all, sizeof(arginfo_ini_get_all) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ini_set", & zif_ini_set, arginfo_ini_set, sizeof(arginfo_ini_set) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ini_alter", & zif_ini_set, arginfo_ini_set, sizeof(arginfo_ini_set) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ini_restore", & zif_ini_restore, arginfo_ini_restore, sizeof(arginfo_ini_restore) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_include_path", & zif_get_include_path, arginfo_get_include_path, sizeof(arginfo_get_include_path) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"set_include_path", & zif_set_include_path, arginfo_set_include_path, sizeof(arginfo_set_include_path) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"restore_include_path", & zif_restore_include_path, arginfo_restore_include_path, sizeof(arginfo_restore_include_path) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"setcookie", & zif_setcookie, arginfo_setcookie, sizeof(arginfo_setcookie) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"setrawcookie", & zif_setrawcookie, arginfo_setrawcookie, sizeof(arginfo_setrawcookie) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"header", & zif_header, arginfo_header, sizeof(arginfo_header) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"header_remove", & zif_header_remove, arginfo_header_remove, sizeof(arginfo_header_remove) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"headers_sent", & zif_headers_sent, arginfo_headers_sent, sizeof(arginfo_headers_sent) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"headers_list", & zif_headers_list, arginfo_headers_list, sizeof(arginfo_headers_list) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"http_response_code", & zif_http_response_code, arginfo_http_response_code, sizeof(arginfo_http_response_code) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"connection_aborted", & zif_connection_aborted, arginfo_connection_aborted, sizeof(arginfo_connection_aborted) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"connection_status", & zif_connection_status, arginfo_connection_status, sizeof(arginfo_connection_status) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ignore_user_abort", & zif_ignore_user_abort, arginfo_ignore_user_abort, sizeof(arginfo_ignore_user_abort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"parse_ini_file", & zif_parse_ini_file, arginfo_parse_ini_file, sizeof(arginfo_parse_ini_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"parse_ini_string", & zif_parse_ini_string, arginfo_parse_ini_string, sizeof(arginfo_parse_ini_string) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_uploaded_file", & zif_is_uploaded_file, arginfo_is_uploaded_file, sizeof(arginfo_is_uploaded_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"move_uploaded_file", & zif_move_uploaded_file, arginfo_move_uploaded_file, sizeof(arginfo_move_uploaded_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gethostbyaddr", & zif_gethostbyaddr, arginfo_gethostbyaddr, sizeof(arginfo_gethostbyaddr) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gethostbyname", & zif_gethostbyname, arginfo_gethostbyname, sizeof(arginfo_gethostbyname) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gethostbynamel", & zif_gethostbynamel, arginfo_gethostbynamel, sizeof(arginfo_gethostbynamel) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gethostname", & zif_gethostname, arginfo_gethostname, sizeof(arginfo_gethostname) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"dns_check_record", & zif_dns_check_record, arginfo_dns_check_record, sizeof(arginfo_dns_check_record) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"checkdnsrr", & zif_dns_check_record, arginfo_dns_check_record, sizeof(arginfo_dns_check_record) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"dns_get_mx", & zif_dns_get_mx, arginfo_dns_get_mx, sizeof(arginfo_dns_get_mx) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getmxrr", & zif_dns_get_mx, arginfo_dns_get_mx, sizeof(arginfo_dns_get_mx) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"dns_get_record", & zif_dns_get_record, arginfo_dns_get_record, sizeof(arginfo_dns_get_record) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"intval", & zif_intval, arginfo_intval, sizeof(arginfo_intval) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"floatval", & zif_floatval, arginfo_floatval, sizeof(arginfo_floatval) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"doubleval", & zif_floatval, arginfo_floatval, sizeof(arginfo_floatval) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"strval", & zif_strval, arginfo_strval, sizeof(arginfo_strval) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"gettype", & zif_gettype, arginfo_gettype, sizeof(arginfo_gettype) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"settype", & zif_settype, arginfo_settype, sizeof(arginfo_settype) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_null", & zif_is_null, arginfo_is_null, sizeof(arginfo_is_null) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_resource", & zif_is_resource, arginfo_is_resource, sizeof(arginfo_is_resource) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_bool", & zif_is_bool, arginfo_is_bool, sizeof(arginfo_is_bool) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_long", & zif_is_long, arginfo_is_long, sizeof(arginfo_is_long) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_float", & zif_is_float, arginfo_is_float, sizeof(arginfo_is_float) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_int", & zif_is_long, arginfo_is_long, sizeof(arginfo_is_long) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_integer", & zif_is_long, arginfo_is_long, sizeof(arginfo_is_long) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_double", & zif_is_float, arginfo_is_float, sizeof(arginfo_is_float) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_real", & zif_is_float, arginfo_is_float, sizeof(arginfo_is_float) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_numeric", & zif_is_numeric, arginfo_is_numeric, sizeof(arginfo_is_numeric) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_string", & zif_is_string, arginfo_is_string, sizeof(arginfo_is_string) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_array", & zif_is_array, arginfo_is_array, sizeof(arginfo_is_array) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_object", & zif_is_object, arginfo_is_object, sizeof(arginfo_is_object) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_scalar", & zif_is_scalar, arginfo_is_scalar, sizeof(arginfo_is_scalar) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_callable", & zif_is_callable, arginfo_is_callable, sizeof(arginfo_is_callable) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pclose", & zif_pclose, arginfo_pclose, sizeof(arginfo_pclose) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"popen", & zif_popen, arginfo_popen, sizeof(arginfo_popen) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"readfile", & zif_readfile, arginfo_readfile, sizeof(arginfo_readfile) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rewind", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_rewind), arginfo_rewind, sizeof(arginfo_rewind) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rmdir", & zif_rmdir, arginfo_rmdir, sizeof(arginfo_rmdir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"umask", & zif_umask, arginfo_umask, sizeof(arginfo_umask) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fclose", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fclose), arginfo_fclose, sizeof(arginfo_fclose) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"feof", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_feof), arginfo_feof, sizeof(arginfo_feof) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fgetc", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fgetc), arginfo_fgetc, sizeof(arginfo_fgetc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fgets", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fgets), arginfo_fgets, sizeof(arginfo_fgets) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fgetss", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fgetss), arginfo_fgetss, sizeof(arginfo_fgetss) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fread", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fread), arginfo_fread, sizeof(arginfo_fread) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fopen", & php_if_fopen, arginfo_fopen, sizeof(arginfo_fopen) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fpassthru", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fpassthru), arginfo_fpassthru, sizeof(arginfo_fpassthru) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ftruncate", & php_if_ftruncate, arginfo_ftruncate, sizeof(arginfo_ftruncate) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fstat", & php_if_fstat, arginfo_fstat, sizeof(arginfo_fstat) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fseek", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fseek), arginfo_fseek, sizeof(arginfo_fseek) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ftell", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_ftell), arginfo_ftell, sizeof(arginfo_ftell) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fflush", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fflush), arginfo_fflush, sizeof(arginfo_fflush) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fwrite", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fwrite), arginfo_fwrite, sizeof(arginfo_fwrite) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fputs", (void (*)(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ))(& zif_fwrite), arginfo_fwrite, sizeof(arginfo_fwrite) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"mkdir", & zif_mkdir, arginfo_mkdir, sizeof(arginfo_mkdir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rename", & zif_rename, arginfo_rename, sizeof(arginfo_rename) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"copy", & zif_copy, arginfo_copy, sizeof(arginfo_copy) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"tempnam", & zif_tempnam, arginfo_tempnam, sizeof(arginfo_tempnam) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"tmpfile", & php_if_tmpfile, arginfo_tmpfile, sizeof(arginfo_tmpfile) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"file", & zif_file, arginfo_file, sizeof(arginfo_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"file_get_contents", & zif_file_get_contents, arginfo_file_get_contents, sizeof(arginfo_file_get_contents) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"file_put_contents", & zif_file_put_contents, arginfo_file_put_contents, sizeof(arginfo_file_put_contents) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_select", & zif_stream_select, arginfo_stream_select, sizeof(arginfo_stream_select) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_create", & zif_stream_context_create, arginfo_stream_context_create, sizeof(arginfo_stream_context_create) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_set_params", & zif_stream_context_set_params, arginfo_stream_context_set_params, sizeof(arginfo_stream_context_set_params) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_get_params", & zif_stream_context_get_params, arginfo_stream_context_get_params, sizeof(arginfo_stream_context_get_params) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_set_option", & zif_stream_context_set_option, arginfo_stream_context_set_option, sizeof(arginfo_stream_context_set_option) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_get_options", & zif_stream_context_get_options, arginfo_stream_context_get_options, sizeof(arginfo_stream_context_get_options) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_get_default", & zif_stream_context_get_default, arginfo_stream_context_get_default, sizeof(arginfo_stream_context_get_default) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_context_set_default", & zif_stream_context_set_default, arginfo_stream_context_set_default, sizeof(arginfo_stream_context_set_default) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_filter_prepend", & zif_stream_filter_prepend, arginfo_stream_filter_prepend, sizeof(arginfo_stream_filter_prepend) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_filter_append", & zif_stream_filter_append, arginfo_stream_filter_append, sizeof(arginfo_stream_filter_append) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_filter_remove", & zif_stream_filter_remove, arginfo_stream_filter_remove, sizeof(arginfo_stream_filter_remove) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_client", & zif_stream_socket_client, arginfo_stream_socket_client, sizeof(arginfo_stream_socket_client) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_server", & zif_stream_socket_server, arginfo_stream_socket_server, sizeof(arginfo_stream_socket_server) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_accept", & zif_stream_socket_accept, arginfo_stream_socket_accept, sizeof(arginfo_stream_socket_accept) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_get_name", & zif_stream_socket_get_name, arginfo_stream_socket_get_name, sizeof(arginfo_stream_socket_get_name) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_recvfrom", & zif_stream_socket_recvfrom, arginfo_stream_socket_recvfrom, sizeof(arginfo_stream_socket_recvfrom) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_sendto", & zif_stream_socket_sendto, arginfo_stream_socket_sendto, sizeof(arginfo_stream_socket_sendto) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_enable_crypto", & zif_stream_socket_enable_crypto, arginfo_stream_socket_enable_crypto, sizeof(arginfo_stream_socket_enable_crypto) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_shutdown", & zif_stream_socket_shutdown, arginfo_stream_socket_shutdown, sizeof(arginfo_stream_socket_shutdown) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_socket_pair", & zif_stream_socket_pair, arginfo_stream_socket_pair, sizeof(arginfo_stream_socket_pair) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_copy_to_stream", & zif_stream_copy_to_stream, arginfo_stream_copy_to_stream, sizeof(arginfo_stream_copy_to_stream) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_get_contents", & zif_stream_get_contents, arginfo_stream_get_contents, sizeof(arginfo_stream_get_contents) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_supports_lock", & zif_stream_supports_lock, arginfo_stream_supports_lock, sizeof(arginfo_stream_supports_lock) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fgetcsv", & zif_fgetcsv, arginfo_fgetcsv, sizeof(arginfo_fgetcsv) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fputcsv", & zif_fputcsv, arginfo_fputcsv, sizeof(arginfo_fputcsv) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"flock", & zif_flock, arginfo_flock, sizeof(arginfo_flock) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_meta_tags", & zif_get_meta_tags, arginfo_get_meta_tags, sizeof(arginfo_get_meta_tags) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_set_read_buffer", & zif_stream_set_read_buffer, arginfo_stream_set_read_buffer, sizeof(arginfo_stream_set_read_buffer) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_set_write_buffer", & zif_stream_set_write_buffer, arginfo_stream_set_write_buffer, sizeof(arginfo_stream_set_write_buffer) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"set_file_buffer", & zif_stream_set_write_buffer, arginfo_stream_set_write_buffer, sizeof(arginfo_stream_set_write_buffer) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_set_chunk_size", & zif_stream_set_chunk_size, arginfo_stream_set_chunk_size, sizeof(arginfo_stream_set_chunk_size) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"set_socket_blocking", & zif_stream_set_blocking, arginfo_stream_set_blocking, sizeof(arginfo_stream_set_blocking) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0x40000}, 
        {"stream_set_blocking", & zif_stream_set_blocking, arginfo_stream_set_blocking, sizeof(arginfo_stream_set_blocking) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"socket_set_blocking", & zif_stream_set_blocking, arginfo_stream_set_blocking, sizeof(arginfo_stream_set_blocking) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_get_meta_data", & zif_stream_get_meta_data, arginfo_stream_get_meta_data, sizeof(arginfo_stream_get_meta_data) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_get_line", & zif_stream_get_line, arginfo_stream_get_line, sizeof(arginfo_stream_get_line) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_wrapper_register", & zif_stream_wrapper_register, arginfo_stream_wrapper_register, sizeof(arginfo_stream_wrapper_register) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_register_wrapper", & zif_stream_wrapper_register, arginfo_stream_wrapper_register, sizeof(arginfo_stream_wrapper_register) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_wrapper_unregister", & zif_stream_wrapper_unregister, arginfo_stream_wrapper_unregister, sizeof(arginfo_stream_wrapper_unregister) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_wrapper_restore", & zif_stream_wrapper_restore, arginfo_stream_wrapper_restore, sizeof(arginfo_stream_wrapper_restore) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_get_wrappers", & zif_stream_get_wrappers, arginfo_stream_get_wrappers, sizeof(arginfo_stream_get_wrappers) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_get_transports", & zif_stream_get_transports, arginfo_stream_get_transports, sizeof(arginfo_stream_get_transports) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_resolve_include_path", & zif_stream_resolve_include_path, arginfo_stream_resolve_include_path, sizeof(arginfo_stream_resolve_include_path) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_is_local", & zif_stream_is_local, arginfo_stream_is_local, sizeof(arginfo_stream_is_local) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_headers", & zif_get_headers, arginfo_get_headers, sizeof(arginfo_get_headers) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_set_timeout", & zif_stream_set_timeout, arginfo_stream_set_timeout, sizeof(arginfo_stream_set_timeout) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"socket_set_timeout", & zif_stream_set_timeout, arginfo_stream_set_timeout, sizeof(arginfo_stream_set_timeout) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"socket_get_status", & zif_stream_get_meta_data, arginfo_stream_get_meta_data, sizeof(arginfo_stream_get_meta_data) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"realpath", & zif_realpath, arginfo_realpath, sizeof(arginfo_realpath) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fnmatch", & zif_fnmatch, arginfo_fnmatch, sizeof(arginfo_fnmatch) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fsockopen", & zif_fsockopen, arginfo_fsockopen, sizeof(arginfo_fsockopen) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pfsockopen", & zif_pfsockopen, arginfo_pfsockopen, sizeof(arginfo_pfsockopen) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pack", & zif_pack, arginfo_pack, sizeof(arginfo_pack) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"unpack", & zif_unpack, arginfo_unpack, sizeof(arginfo_unpack) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"get_browser", & zif_get_browser, arginfo_get_browser, sizeof(arginfo_get_browser) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"crypt", & zif_crypt, arginfo_crypt, sizeof(arginfo_crypt) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"opendir", & zif_opendir, arginfo_opendir, sizeof(arginfo_opendir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"closedir", & zif_closedir, arginfo_closedir, sizeof(arginfo_closedir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chdir", & zif_chdir, arginfo_chdir, sizeof(arginfo_chdir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"getcwd", & zif_getcwd, arginfo_getcwd, sizeof(arginfo_getcwd) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rewinddir", & zif_rewinddir, arginfo_rewinddir, sizeof(arginfo_rewinddir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"readdir", & php_if_readdir, arginfo_readdir, sizeof(arginfo_readdir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"dir", & zif_getdir, arginfo_dir, sizeof(arginfo_dir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"scandir", & zif_scandir, arginfo_scandir, sizeof(arginfo_scandir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"glob", & zif_glob, arginfo_glob, sizeof(arginfo_glob) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fileatime", & zif_fileatime, arginfo_fileatime, sizeof(arginfo_fileatime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"filectime", & zif_filectime, arginfo_filectime, sizeof(arginfo_filectime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"filegroup", & zif_filegroup, arginfo_filegroup, sizeof(arginfo_filegroup) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fileinode", & zif_fileinode, arginfo_fileinode, sizeof(arginfo_fileinode) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"filemtime", & zif_filemtime, arginfo_filemtime, sizeof(arginfo_filemtime) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fileowner", & zif_fileowner, arginfo_fileowner, sizeof(arginfo_fileowner) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"fileperms", & zif_fileperms, arginfo_fileperms, sizeof(arginfo_fileperms) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"filesize", & zif_filesize, arginfo_filesize, sizeof(arginfo_filesize) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"filetype", & zif_filetype, arginfo_filetype, sizeof(arginfo_filetype) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"file_exists", & zif_file_exists, arginfo_file_exists, sizeof(arginfo_file_exists) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_writable", & zif_is_writable, arginfo_is_writable, sizeof(arginfo_is_writable) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_writeable", & zif_is_writable, arginfo_is_writable, sizeof(arginfo_is_writable) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_readable", & zif_is_readable, arginfo_is_readable, sizeof(arginfo_is_readable) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_executable", & zif_is_executable, arginfo_is_executable, sizeof(arginfo_is_executable) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_file", & zif_is_file, arginfo_is_file, sizeof(arginfo_is_file) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_dir", & zif_is_dir, arginfo_is_dir, sizeof(arginfo_is_dir) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"is_link", & zif_is_link, arginfo_is_link, sizeof(arginfo_is_link) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stat", & php_if_stat, arginfo_stat, sizeof(arginfo_stat) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"lstat", & php_if_lstat, arginfo_lstat, sizeof(arginfo_lstat) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chown", & zif_chown, arginfo_chown, sizeof(arginfo_chown) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chgrp", & zif_chgrp, arginfo_chgrp, sizeof(arginfo_chgrp) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"lchown", & zif_lchown, arginfo_lchown, sizeof(arginfo_lchown) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"lchgrp", & zif_lchgrp, arginfo_lchgrp, sizeof(arginfo_lchgrp) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"chmod", & zif_chmod, arginfo_chmod, sizeof(arginfo_chmod) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"touch", & zif_touch, arginfo_touch, sizeof(arginfo_touch) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"clearstatcache", & zif_clearstatcache, arginfo_clearstatcache, sizeof(arginfo_clearstatcache) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"disk_total_space", & zif_disk_total_space, arginfo_disk_total_space, sizeof(arginfo_disk_total_space) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"disk_free_space", & zif_disk_free_space, arginfo_disk_free_space, sizeof(arginfo_disk_free_space) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"diskfreespace", & zif_disk_free_space, arginfo_disk_free_space, sizeof(arginfo_disk_free_space) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"realpath_cache_size", & zif_realpath_cache_size, arginfo_realpath_cache_size, sizeof(arginfo_realpath_cache_size) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"realpath_cache_get", & zif_realpath_cache_get, arginfo_realpath_cache_get, sizeof(arginfo_realpath_cache_get) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"mail", & zif_mail, arginfo_mail, sizeof(arginfo_mail) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ezmlm_hash", & zif_ezmlm_hash, arginfo_ezmlm_hash, sizeof(arginfo_ezmlm_hash) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"openlog", & zif_openlog, arginfo_openlog, sizeof(arginfo_openlog) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"syslog", & zif_syslog, arginfo_syslog, sizeof(arginfo_syslog) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"closelog", & zif_closelog, arginfo_closelog, sizeof(arginfo_closelog) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"lcg_value", & zif_lcg_value, arginfo_lcg_value, sizeof(arginfo_lcg_value) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"metaphone", & zif_metaphone, arginfo_metaphone, sizeof(arginfo_metaphone) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_start", & zif_ob_start, arginfo_ob_start, sizeof(arginfo_ob_start) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_flush", & zif_ob_flush, arginfo_ob_flush, sizeof(arginfo_ob_flush) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_clean", & zif_ob_clean, arginfo_ob_clean, sizeof(arginfo_ob_clean) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_end_flush", & zif_ob_end_flush, arginfo_ob_end_flush, sizeof(arginfo_ob_end_flush) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_end_clean", & zif_ob_end_clean, arginfo_ob_end_clean, sizeof(arginfo_ob_end_clean) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_get_flush", & zif_ob_get_flush, arginfo_ob_get_flush, sizeof(arginfo_ob_get_flush) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_get_clean", & zif_ob_get_clean, arginfo_ob_get_clean, sizeof(arginfo_ob_get_clean) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_get_length", & zif_ob_get_length, arginfo_ob_get_length, sizeof(arginfo_ob_get_length) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_get_level", & zif_ob_get_level, arginfo_ob_get_level, sizeof(arginfo_ob_get_level) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_get_status", & zif_ob_get_status, arginfo_ob_get_status, sizeof(arginfo_ob_get_status) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_get_contents", & zif_ob_get_contents, arginfo_ob_get_contents, sizeof(arginfo_ob_get_contents) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_implicit_flush", & zif_ob_implicit_flush, arginfo_ob_implicit_flush, sizeof(arginfo_ob_implicit_flush) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ob_list_handlers", & zif_ob_list_handlers, arginfo_ob_list_handlers, sizeof(arginfo_ob_list_handlers) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ksort", & zif_ksort, arginfo_ksort, sizeof(arginfo_ksort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"krsort", & zif_krsort, arginfo_krsort, sizeof(arginfo_krsort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"natsort", & zif_natsort, arginfo_natsort, sizeof(arginfo_natsort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"natcasesort", & zif_natcasesort, arginfo_natcasesort, sizeof(arginfo_natcasesort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"asort", & zif_asort, arginfo_asort, sizeof(arginfo_asort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"arsort", & zif_arsort, arginfo_arsort, sizeof(arginfo_arsort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sort", & zif_sort, arginfo_sort, sizeof(arginfo_sort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"rsort", & zif_rsort, arginfo_rsort, sizeof(arginfo_rsort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"usort", & zif_usort, arginfo_usort, sizeof(arginfo_usort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"uasort", & zif_uasort, arginfo_uasort, sizeof(arginfo_uasort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"uksort", & zif_uksort, arginfo_uksort, sizeof(arginfo_uksort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"shuffle", & zif_shuffle, arginfo_shuffle, sizeof(arginfo_shuffle) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_walk", & zif_array_walk, arginfo_array_walk, sizeof(arginfo_array_walk) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_walk_recursive", & zif_array_walk_recursive, arginfo_array_walk_recursive, sizeof(arginfo_array_walk_recursive) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"count", & zif_count, arginfo_count, sizeof(arginfo_count) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"end", & zif_end, arginfo_end, sizeof(arginfo_end) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"prev", & zif_prev, arginfo_prev, sizeof(arginfo_prev) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"next", & zif_next, arginfo_next, sizeof(arginfo_next) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"reset", & zif_reset, arginfo_reset, sizeof(arginfo_reset) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"current", & zif_current, arginfo_current, sizeof(arginfo_current) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"key", & zif_key, arginfo_key, sizeof(arginfo_key) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"min", & zif_min, arginfo_min, sizeof(arginfo_min) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"max", & zif_max, arginfo_max, sizeof(arginfo_max) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"in_array", & zif_in_array, arginfo_in_array, sizeof(arginfo_in_array) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_search", & zif_array_search, arginfo_array_search, sizeof(arginfo_array_search) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"extract", & zif_extract, arginfo_extract, sizeof(arginfo_extract) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"compact", & zif_compact, arginfo_compact, sizeof(arginfo_compact) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_fill", & zif_array_fill, arginfo_array_fill, sizeof(arginfo_array_fill) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_fill_keys", & zif_array_fill_keys, arginfo_array_fill_keys, sizeof(arginfo_array_fill_keys) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"range", & zif_range, arginfo_range, sizeof(arginfo_range) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_multisort", & zif_array_multisort, arginfo_array_multisort, sizeof(arginfo_array_multisort) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_push", & zif_array_push, arginfo_array_push, sizeof(arginfo_array_push) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_pop", & zif_array_pop, arginfo_array_pop, sizeof(arginfo_array_pop) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_shift", & zif_array_shift, arginfo_array_shift, sizeof(arginfo_array_shift) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_unshift", & zif_array_unshift, arginfo_array_unshift, sizeof(arginfo_array_unshift) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_splice", & zif_array_splice, arginfo_array_splice, sizeof(arginfo_array_splice) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_slice", & zif_array_slice, arginfo_array_slice, sizeof(arginfo_array_slice) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_merge", & zif_array_merge, arginfo_array_merge, sizeof(arginfo_array_merge) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_merge_recursive", & zif_array_merge_recursive, arginfo_array_merge_recursive, sizeof(arginfo_array_merge_recursive) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_replace", & zif_array_replace, arginfo_array_replace, sizeof(arginfo_array_replace) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_replace_recursive", & zif_array_replace_recursive, arginfo_array_replace_recursive, sizeof(arginfo_array_replace_recursive) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_keys", & zif_array_keys, arginfo_array_keys, sizeof(arginfo_array_keys) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_values", & zif_array_values, arginfo_array_values, sizeof(arginfo_array_values) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_count_values", & zif_array_count_values, arginfo_array_count_values, sizeof(arginfo_array_count_values) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_reverse", & zif_array_reverse, arginfo_array_reverse, sizeof(arginfo_array_reverse) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_reduce", & zif_array_reduce, arginfo_array_reduce, sizeof(arginfo_array_reduce) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_pad", & zif_array_pad, arginfo_array_pad, sizeof(arginfo_array_pad) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_flip", & zif_array_flip, arginfo_array_flip, sizeof(arginfo_array_flip) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_change_key_case", & zif_array_change_key_case, arginfo_array_change_key_case, sizeof(arginfo_array_change_key_case) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_rand", & zif_array_rand, arginfo_array_rand, sizeof(arginfo_array_rand) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_unique", & zif_array_unique, arginfo_array_unique, sizeof(arginfo_array_unique) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_intersect", & zif_array_intersect, arginfo_array_intersect, sizeof(arginfo_array_intersect) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_intersect_key", & zif_array_intersect_key, arginfo_array_intersect_key, sizeof(arginfo_array_intersect_key) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_intersect_ukey", & zif_array_intersect_ukey, arginfo_array_intersect_ukey, sizeof(arginfo_array_intersect_ukey) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_uintersect", & zif_array_uintersect, arginfo_array_uintersect, sizeof(arginfo_array_uintersect) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_intersect_assoc", & zif_array_intersect_assoc, arginfo_array_intersect_assoc, sizeof(arginfo_array_intersect_assoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_uintersect_assoc", & zif_array_uintersect_assoc, arginfo_array_uintersect_assoc, sizeof(arginfo_array_uintersect_assoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_intersect_uassoc", & zif_array_intersect_uassoc, arginfo_array_intersect_uassoc, sizeof(arginfo_array_intersect_uassoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_uintersect_uassoc", & zif_array_uintersect_uassoc, arginfo_array_uintersect_uassoc, sizeof(arginfo_array_uintersect_uassoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_diff", & zif_array_diff, arginfo_array_diff, sizeof(arginfo_array_diff) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_diff_key", & zif_array_diff_key, arginfo_array_diff_key, sizeof(arginfo_array_diff_key) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_diff_ukey", & zif_array_diff_ukey, arginfo_array_diff_ukey, sizeof(arginfo_array_diff_ukey) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_udiff", & zif_array_udiff, arginfo_array_udiff, sizeof(arginfo_array_udiff) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_diff_assoc", & zif_array_diff_assoc, arginfo_array_diff_assoc, sizeof(arginfo_array_diff_assoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_udiff_assoc", & zif_array_udiff_assoc, arginfo_array_udiff_assoc, sizeof(arginfo_array_udiff_assoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_diff_uassoc", & zif_array_diff_uassoc, arginfo_array_diff_uassoc, sizeof(arginfo_array_diff_uassoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_udiff_uassoc", & zif_array_udiff_uassoc, arginfo_array_udiff_uassoc, sizeof(arginfo_array_udiff_uassoc) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_sum", & zif_array_sum, arginfo_array_sum, sizeof(arginfo_array_sum) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_product", & zif_array_product, arginfo_array_product, sizeof(arginfo_array_product) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_filter", & zif_array_filter, arginfo_array_filter, sizeof(arginfo_array_filter) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_map", & zif_array_map, arginfo_array_map, sizeof(arginfo_array_map) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_chunk", & zif_array_chunk, arginfo_array_chunk, sizeof(arginfo_array_chunk) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_combine", & zif_array_combine, arginfo_array_combine, sizeof(arginfo_array_combine) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"array_key_exists", & zif_array_key_exists, arginfo_array_key_exists, sizeof(arginfo_array_key_exists) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"pos", & zif_current, arginfo_current, sizeof(arginfo_current) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sizeof", & zif_count, arginfo_count, sizeof(arginfo_count) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"key_exists", & zif_array_key_exists, arginfo_array_key_exists, sizeof(arginfo_array_key_exists) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"assert", & zif_assert, arginfo_assert, sizeof(arginfo_assert) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"assert_options", & zif_assert_options, arginfo_assert_options, sizeof(arginfo_assert_options) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"version_compare", & zif_version_compare, arginfo_version_compare, sizeof(arginfo_version_compare) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"ftok", & zif_ftok, arginfo_ftok, sizeof(arginfo_ftok) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"str_rot13", & zif_str_rot13, arginfo_str_rot13, sizeof(arginfo_str_rot13) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_get_filters", & zif_stream_get_filters, arginfo_stream_get_filters, sizeof(arginfo_stream_get_filters) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_filter_register", & zif_stream_filter_register, arginfo_stream_filter_register, sizeof(arginfo_stream_filter_register) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_bucket_make_writeable", & zif_stream_bucket_make_writeable, arginfo_stream_bucket_make_writeable, sizeof(arginfo_stream_bucket_make_writeable) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_bucket_prepend", & zif_stream_bucket_prepend, arginfo_stream_bucket_prepend, sizeof(arginfo_stream_bucket_prepend) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_bucket_append", & zif_stream_bucket_append, arginfo_stream_bucket_append, sizeof(arginfo_stream_bucket_append) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"stream_bucket_new", & zif_stream_bucket_new, arginfo_stream_bucket_new, sizeof(arginfo_stream_bucket_new) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"output_add_rewrite_var", & zif_output_add_rewrite_var, arginfo_output_add_rewrite_var, sizeof(arginfo_output_add_rewrite_var) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"output_reset_rewrite_vars", & zif_output_reset_rewrite_vars, arginfo_output_reset_rewrite_vars, sizeof(arginfo_output_reset_rewrite_vars) / sizeof(struct _zend_arg_info ) - 1U, (zend_uint )0}, 
        {"sys_get_temp_dir", & zif_sys_get_temp_dir, arginfo_sys_get_temp_dir, sizeof(arginfo_sys_get_temp_dir) / 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), (zend_uint )0, (zend_uint )0}};
static zend_module_dep const   standard_deps[2]  = {      {"session", (char const   *)((void *)0), (char const   *)((void *)0), (unsigned char)3}, 
        {(char const   *)((void *)0), (char const   *)((void *)0), (char const   *)((void *)0), (unsigned char)0}};
zend_module_entry basic_functions_module  = 
     {(unsigned short )sizeof(zend_module_entry ), 20100525U, (unsigned char)0, (unsigned char)0, (struct _zend_ini_entry  const  *)((void *)0), standard_deps, "standard", basic_functions, & zm_startup_basic, & zm_shutdown_basic, & zm_activate_basic, & zm_deactivate_basic, & zm_info_basic, "5.5.0-dev", (size_t )0, (void *)0, (void (*)(void *global ))((void *)0), (void (*)(void *global ))((void *)0), (int (*)(void))((void *)0), 0, (unsigned char)0, (void *)0, 0, "API20100525,NTS"};
static void php_putenv_destructor(putenv_entry *pe ) 
{ size_t tmp ;
  size_t tmp___0 ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___4 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  size_t tmp___10 ;
  size_t tmp___11 ;

  {
  if (pe->previous_value) {
    putenv(pe->previous_value);
  } else {
    unsetenv((char const   *)pe->key);
  }
  if (0) {
    if (0) {
      __s1_len = strlen((char const   *)pe->key);
      __s2_len = strlen("TZ");
      if (! ((unsigned int )((void const   *)(pe->key + 1)) - (unsigned int )((void const   *)pe->key) == 1U)) {
        goto _L___0;
      } else {
        if (__s1_len >= 4U) {
          _L___0: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)("TZ" + 1)) - (unsigned int )((void const   *)"TZ") == 1U)) {
            tmp___7 = 1;
          } else {
            if (__s2_len >= 4U) {
              tmp___7 = 1;
            } else {
              tmp___7 = 0;
            }
          }
        } else {
          tmp___7 = 0;
        }
      }
      if (tmp___7) {
        tmp___2 = __builtin_strcmp((char const   *)pe->key, "TZ");
        tmp___6 = tmp___2;
      } else {
        tmp___5 = __builtin_strcmp((char const   *)pe->key, "TZ");
        tmp___6 = tmp___5;
      }
    } else {
      tmp___5 = __builtin_strcmp((char const   *)pe->key, "TZ");
      tmp___6 = tmp___5;
    }
    tmp___9 = tmp___6;
  } else {
    tmp___8 = strncmp((char const   *)pe->key, "TZ", (unsigned int )pe->key_len);
    tmp___9 = tmp___8;
  }
  if (tmp___9) {

  } else {
    tzset();
  }
  _efree((void *)pe->putenv_string);
  _efree((void *)pe->key);
  return;
}
}
static void basic_globals_ctor(php_basic_globals *basic_globals_p ) 
{ 

  {
  basic_globals.rand_is_seeded = (unsigned char)0;
  basic_globals.mt_rand_is_seeded = (unsigned char)0;
  basic_globals.umask = -1;
  basic_globals.next = (php_uint32 *)((void *)0);
  basic_globals.left = -1;
  basic_globals.user_tick_functions = (zend_llist *)((void *)0);
  basic_globals.user_filter_map = (HashTable *)((void *)0);
  basic_globals.serialize_lock = 0U;
  memset((void *)(& basic_globals.serialize), 0, sizeof(basic_globals.serialize));
  memset((void *)(& basic_globals.unserialize), 0, sizeof(basic_globals.unserialize));
  memset((void *)(& basic_globals.url_adapt_state_ex), 0, sizeof(basic_globals.url_adapt_state_ex));
  basic_globals.incomplete_class = incomplete_class_entry;
  basic_globals.page_uid = -1L;
  basic_globals.page_gid = -1L;
  return;
}
}
static void basic_globals_dtor(php_basic_globals *basic_globals_p ) 
{ 

  {
  if (basic_globals.url_adapt_state_ex.tags) {
    zend_hash_destroy(basic_globals.url_adapt_state_ex.tags);
    free((void *)basic_globals.url_adapt_state_ex.tags);
  } else {

  }
  return;
}
}
double __attribute__((__visibility__("default")))  php_get_nan(void) 
{ double tmp ;
  double tmp___0 ;

  {
  tmp = __builtin_huge_val();
  tmp___0 = __builtin_huge_val();
  return ((double __attribute__((__visibility__("default")))  )(tmp + - tmp___0));
}
}
double __attribute__((__visibility__("default")))  php_get_inf(void) 
{ double tmp ;

  {
  tmp = __builtin_huge_val();
  return ((double __attribute__((__visibility__("default")))  )tmp);
}
}
int zm_startup_basic(int type , int module_number ) 
{ zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  double __attribute__((__visibility__("default")))  tmp___0 ;
  double __attribute__((__visibility__("default")))  tmp___1 ;
  size_t tmp___2 ;
  size_t tmp___3 ;
  size_t tmp___4 ;
  int tmp___5 ;
  size_t tmp___6 ;
  int tmp___7 ;
  size_t tmp___8 ;
  int tmp___9 ;
  size_t tmp___10 ;
  int tmp___11 ;
  size_t tmp___12 ;
  int tmp___13 ;
  size_t tmp___14 ;
  int tmp___15 ;
  size_t tmp___16 ;
  int tmp___17 ;
  size_t tmp___18 ;
  int tmp___19 ;
  size_t tmp___20 ;
  int tmp___21 ;
  size_t tmp___22 ;
  int tmp___23 ;
  size_t tmp___24 ;
  int tmp___25 ;
  size_t tmp___26 ;
  int tmp___27 ;
  size_t tmp___28 ;
  int tmp___29 ;
  size_t tmp___30 ;
  int tmp___31 ;
  size_t tmp___32 ;
  int tmp___33 ;
  size_t tmp___34 ;
  int tmp___35 ;
  size_t tmp___36 ;
  int tmp___37 ;

  {
  basic_globals_ctor((php_basic_globals *)(& basic_globals));
  _zend_hash_init(& basic_submodules, 0U, (ulong (*)(char const   *arKey , uint nKeyLength ))((void *)0), (void (*)(void *pDest ))((void *)0), (unsigned char)1);
  tmp = php_create_incomplete_class();
  incomplete_class_entry = (zend_class_entry *)tmp;
  basic_globals.incomplete_class = incomplete_class_entry;
  zend_register_long_constant("CONNECTION_ABORTED", sizeof("CONNECTION_ABORTED"), 1L, 1 | (1 << 1), module_number);
  zend_register_long_constant("CONNECTION_NORMAL", sizeof("CONNECTION_NORMAL"), 0L, 1 | (1 << 1), module_number);
  zend_register_long_constant("CONNECTION_TIMEOUT", sizeof("CONNECTION_TIMEOUT"), 2L, 1 | (1 << 1), module_number);
  zend_register_long_constant("INI_USER", sizeof("INI_USER"), 1L, 1 | (1 << 1), module_number);
  zend_register_long_constant("INI_PERDIR", sizeof("INI_PERDIR"), (long )(1 << 1), 1 | (1 << 1), module_number);
  zend_register_long_constant("INI_SYSTEM", sizeof("INI_SYSTEM"), (long )(1 << 2), 1 | (1 << 1), module_number);
  zend_register_long_constant("INI_ALL", sizeof("INI_ALL"), (long )((1 | (1 << 1)) | (1 << 2)), 1 | (1 << 1), module_number);
  zend_register_long_constant("INI_SCANNER_NORMAL", sizeof("INI_SCANNER_NORMAL"), 0L, 1 | (1 << 1), module_number);
  zend_register_long_constant("INI_SCANNER_RAW", sizeof("INI_SCANNER_RAW"), 1L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_SCHEME", sizeof("PHP_URL_SCHEME"), 0L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_HOST", sizeof("PHP_URL_HOST"), 1L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_PORT", sizeof("PHP_URL_PORT"), 2L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_USER", sizeof("PHP_URL_USER"), 3L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_PASS", sizeof("PHP_URL_PASS"), 4L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_PATH", sizeof("PHP_URL_PATH"), 5L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_QUERY", sizeof("PHP_URL_QUERY"), 6L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_URL_FRAGMENT", sizeof("PHP_URL_FRAGMENT"), 7L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_QUERY_RFC1738", sizeof("PHP_QUERY_RFC1738"), 1L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_QUERY_RFC3986", sizeof("PHP_QUERY_RFC3986"), 2L, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_E", sizeof("M_E"), 2.7182818284590452354, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_LOG2E", sizeof("M_LOG2E"), 1.4426950408889634074, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_LOG10E", sizeof("M_LOG10E"), 0.43429448190325182765, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_LN2", sizeof("M_LN2"), 0.69314718055994530942, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_LN10", sizeof("M_LN10"), 2.30258509299404568402, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_PI", sizeof("M_PI"), 3.14159265358979323846, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_PI_2", sizeof("M_PI_2"), 1.57079632679489661923, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_PI_4", sizeof("M_PI_4"), 0.78539816339744830962, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_1_PI", sizeof("M_1_PI"), 0.31830988618379067154, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_2_PI", sizeof("M_2_PI"), 0.63661977236758134308, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_SQRTPI", sizeof("M_SQRTPI"), 1.77245385090551602729, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_2_SQRTPI", sizeof("M_2_SQRTPI"), 1.12837916709551257390, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_LNPI", sizeof("M_LNPI"), 1.14472988584940017414, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_EULER", sizeof("M_EULER"), 0.57721566490153286061, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_SQRT2", sizeof("M_SQRT2"), 1.41421356237309504880, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_SQRT1_2", sizeof("M_SQRT1_2"), 0.70710678118654752440, 1 | (1 << 1), module_number);
  zend_register_double_constant("M_SQRT3", sizeof("M_SQRT3"), 1.73205080756887729352, 1 | (1 << 1), module_number);
  tmp___0 = php_get_inf();
  zend_register_double_constant("INF", sizeof("INF"), (double )tmp___0, 1 | (1 << 1), module_number);
  tmp___1 = php_get_nan();
  zend_register_double_constant("NAN", sizeof("NAN"), (double )tmp___1, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_ROUND_HALF_UP", sizeof("PHP_ROUND_HALF_UP"), 1L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_ROUND_HALF_DOWN", sizeof("PHP_ROUND_HALF_DOWN"), 2L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_ROUND_HALF_EVEN", sizeof("PHP_ROUND_HALF_EVEN"), 3L, 1 | (1 << 1), module_number);
  zend_register_long_constant("PHP_ROUND_HALF_ODD", sizeof("PHP_ROUND_HALF_ODD"), 4L, 1 | (1 << 1), module_number);
  register_phpinfo_constants(type, module_number);
  register_html_constants(type, module_number);
  register_string_constants(type, module_number);
  tmp___2 = strlen("dl");
  zend_hash_add_empty_element(& basic_submodules, "dl", tmp___2);
  tmp___3 = strlen("mail");
  zend_hash_add_empty_element(& basic_submodules, "mail", tmp___3);
  tmp___5 = zm_startup_file(type, module_number);
  if (tmp___5 == 0) {
    tmp___4 = strlen("file");
    zend_hash_add_empty_element(& basic_submodules, "file", tmp___4);
  } else {

  }
  tmp___7 = zm_startup_pack(type, module_number);
  if (tmp___7 == 0) {
    tmp___6 = strlen("pack");
    zend_hash_add_empty_element(& basic_submodules, "pack", tmp___6);
  } else {

  }
  tmp___9 = zm_startup_browscap(type, module_number);
  if (tmp___9 == 0) {
    tmp___8 = strlen("browscap");
    zend_hash_add_empty_element(& basic_submodules, "browscap", tmp___8);
  } else {

  }
  tmp___11 = zm_startup_standard_filters(type, module_number);
  if (tmp___11 == 0) {
    tmp___10 = strlen("standard_filters");
    zend_hash_add_empty_element(& basic_submodules, "standard_filters", tmp___10);
  } else {

  }
  tmp___13 = zm_startup_user_filters(type, module_number);
  if (tmp___13 == 0) {
    tmp___12 = strlen("user_filters");
    zend_hash_add_empty_element(& basic_submodules, "user_filters", tmp___12);
  } else {

  }
  tmp___15 = zm_startup_nl_langinfo(type, module_number);
  if (tmp___15 == 0) {
    tmp___14 = strlen("nl_langinfo");
    zend_hash_add_empty_element(& basic_submodules, "nl_langinfo", tmp___14);
  } else {

  }
  tmp___17 = zm_startup_crypt(type, module_number);
  if (tmp___17 == 0) {
    tmp___16 = strlen("crypt");
    zend_hash_add_empty_element(& basic_submodules, "crypt", tmp___16);
  } else {

  }
  tmp___19 = zm_startup_lcg(type, module_number);
  if (tmp___19 == 0) {
    tmp___18 = strlen("lcg");
    zend_hash_add_empty_element(& basic_submodules, "lcg", tmp___18);
  } else {

  }
  tmp___21 = zm_startup_dir(type, module_number);
  if (tmp___21 == 0) {
    tmp___20 = strlen("dir");
    zend_hash_add_empty_element(& basic_submodules, "dir", tmp___20);
  } else {

  }
  tmp___23 = zm_startup_syslog(type, module_number);
  if (tmp___23 == 0) {
    tmp___22 = strlen("syslog");
    zend_hash_add_empty_element(& basic_submodules, "syslog", tmp___22);
  } else {

  }
  tmp___25 = zm_startup_array(type, module_number);
  if (tmp___25 == 0) {
    tmp___24 = strlen("array");
    zend_hash_add_empty_element(& basic_submodules, "array", tmp___24);
  } else {

  }
  tmp___27 = zm_startup_assert(type, module_number);
  if (tmp___27 == 0) {
    tmp___26 = strlen("assert");
    zend_hash_add_empty_element(& basic_submodules, "assert", tmp___26);
  } else {

  }
  tmp___29 = zm_startup_url_scanner_ex(type, module_number);
  if (tmp___29 == 0) {
    tmp___28 = strlen("url_scanner_ex");
    zend_hash_add_empty_element(& basic_submodules, "url_scanner_ex", tmp___28);
  } else {

  }
  tmp___31 = zm_startup_proc_open(type, module_number);
  if (tmp___31 == 0) {
    tmp___30 = strlen("proc_open");
    zend_hash_add_empty_element(& basic_submodules, "proc_open", tmp___30);
  } else {

  }
  tmp___33 = zm_startup_user_streams(type, module_number);
  if (tmp___33 == 0) {
    tmp___32 = strlen("user_streams");
    zend_hash_add_empty_element(& basic_submodules, "user_streams", tmp___32);
  } else {

  }
  tmp___35 = zm_startup_imagetypes(type, module_number);
  if (tmp___35 == 0) {
    tmp___34 = strlen("imagetypes");
    zend_hash_add_empty_element(& basic_submodules, "imagetypes", tmp___34);
  } else {

  }
  php_register_url_stream_wrapper((char *)"php", & php_stream_php_wrapper);
  php_register_url_stream_wrapper((char *)"file", (php_stream_wrapper *)(& php_plain_files_wrapper));
  php_register_url_stream_wrapper((char *)"glob", (php_stream_wrapper *)(& php_glob_stream_wrapper));
  php_register_url_stream_wrapper((char *)"data", (php_stream_wrapper *)(& php_stream_rfc2397_wrapper));
  php_register_url_stream_wrapper((char *)"http", (php_stream_wrapper *)(& php_stream_http_wrapper));
  php_register_url_stream_wrapper((char *)"ftp", (php_stream_wrapper *)(& php_stream_ftp_wrapper));
  tmp___37 = zm_startup_dns(type, module_number);
  if (tmp___37 == 0) {
    tmp___36 = strlen("dns");
    zend_hash_add_empty_element(& basic_submodules, "dns", tmp___36);
  } else {

  }
  return (0);
}
}
int zm_shutdown_basic(int type , int module_number ) 
{ size_t tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  size_t tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  size_t tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  size_t tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;
  size_t tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;
  size_t tmp___9 ;
  int __attribute__((__visibility__("default")))  tmp___10 ;
  size_t tmp___11 ;
  int __attribute__((__visibility__("default")))  tmp___12 ;

  {
  zm_shutdown_syslog(type, module_number);
  basic_globals_dtor((php_basic_globals *)(& basic_globals));
  php_unregister_url_stream_wrapper((char *)"php");
  php_unregister_url_stream_wrapper((char *)"http");
  php_unregister_url_stream_wrapper((char *)"ftp");
  tmp = strlen("browscap");
  tmp___0 = zend_hash_exists((HashTable const   *)(& basic_submodules), "browscap", tmp);
  if (tmp___0) {
    zm_shutdown_browscap(type, module_number);
  } else {

  }
  tmp___1 = strlen("array");
  tmp___2 = zend_hash_exists((HashTable const   *)(& basic_submodules), "array", tmp___1);
  if (tmp___2) {
    zm_shutdown_array(type, module_number);
  } else {

  }
  tmp___3 = strlen("assert");
  tmp___4 = zend_hash_exists((HashTable const   *)(& basic_submodules), "assert", tmp___3);
  if (tmp___4) {
    zm_shutdown_assert(type, module_number);
  } else {

  }
  tmp___5 = strlen("url_scanner_ex");
  tmp___6 = zend_hash_exists((HashTable const   *)(& basic_submodules), "url_scanner_ex", tmp___5);
  if (tmp___6) {
    zm_shutdown_url_scanner_ex(type, module_number);
  } else {

  }
  tmp___7 = strlen("file");
  tmp___8 = zend_hash_exists((HashTable const   *)(& basic_submodules), "file", tmp___7);
  if (tmp___8) {
    zm_shutdown_file(type, module_number);
  } else {

  }
  tmp___9 = strlen("standard_filters");
  tmp___10 = zend_hash_exists((HashTable const   *)(& basic_submodules), "standard_filters", tmp___9);
  if (tmp___10) {
    zm_shutdown_standard_filters(type, module_number);
  } else {

  }
  tmp___11 = strlen("crypt");
  tmp___12 = zend_hash_exists((HashTable const   *)(& basic_submodules), "crypt", tmp___11);
  if (tmp___12) {
    zm_shutdown_crypt(type, module_number);
  } else {

  }
  zend_hash_destroy(& basic_submodules);
  return (0);
}
}
int zm_activate_basic(int type , int module_number ) 
{ int __attribute__((__visibility__("default")))  tmp ;
  size_t tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  size_t tmp___2 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;
  size_t tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;

  {
  memset((void *)(basic_globals.strtok_table), 0, 256U);
  basic_globals.strtok_string = (char *)((void *)0);
  basic_globals.strtok_zval = (zval *)((void *)0);
  basic_globals.strtok_last = (char *)((void *)0);
  basic_globals.locale_string = (char *)((void *)0);
  basic_globals.array_walk_fci = (struct _zend_fcall_info )empty_fcall_info;
  basic_globals.array_walk_fci_cache = (struct _zend_fcall_info_cache )empty_fcall_info_cache;
  basic_globals.user_compare_fci = (struct _zend_fcall_info )empty_fcall_info;
  basic_globals.user_compare_fci_cache = (struct _zend_fcall_info_cache )empty_fcall_info_cache;
  basic_globals.page_uid = -1L;
  basic_globals.page_gid = -1L;
  basic_globals.page_inode = -1L;
  basic_globals.page_mtime = -1L;
  tmp = _zend_hash_init(& basic_globals.putenv_ht, 1U, (ulong (*)(char const   *arKey , uint nKeyLength ))((void *)0), (void (*)(void * ))(& php_putenv_destructor), (unsigned char)0);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return (-1);
  } else {

  }
  basic_globals.user_shutdown_function_names = (HashTable *)((void *)0);
  zm_activate_filestat(type, module_number);
  tmp___0 = strlen("syslog");
  tmp___1 = zend_hash_exists((HashTable const   *)(& basic_submodules), "syslog", tmp___0);
  if (tmp___1) {
    zm_activate_syslog(type, module_number);
  } else {

  }
  tmp___2 = strlen("dir");
  tmp___3 = zend_hash_exists((HashTable const   *)(& basic_submodules), "dir", tmp___2);
  if (tmp___3) {
    zm_activate_dir(type, module_number);
  } else {

  }
  tmp___4 = strlen("url_scanner_ex");
  tmp___5 = zend_hash_exists((HashTable const   *)(& basic_submodules), "url_scanner_ex", tmp___4);
  if (tmp___5) {
    zm_activate_url_scanner_ex(type, module_number);
  } else {

  }
  file_globals.default_context = (php_stream_context *)((void *)0);
  file_globals.stream_wrappers = (HashTable *)((void *)0);
  file_globals.stream_filters = (HashTable *)((void *)0);
  file_globals.wrapper_errors = (HashTable *)((void *)0);
  return (0);
}
}
int zm_deactivate_basic(int type , int module_number ) 
{ size_t tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  size_t tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  size_t tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  size_t tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;
  size_t tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;

  {
  if (basic_globals.strtok_zval) {
    _zval_ptr_dtor(& basic_globals.strtok_zval);
  } else {

  }
  basic_globals.strtok_string = (char *)((void *)0);
  basic_globals.strtok_zval = (zval *)((void *)0);
  zend_hash_destroy(& basic_globals.putenv_ht);
  if (basic_globals.umask != -1) {
    umask((unsigned int )basic_globals.umask);
  } else {

  }
  if ((unsigned int )basic_globals.locale_string != (unsigned int )((void *)0)) {
    setlocale(6, "C");
    setlocale(0, "");
  } else {

  }
  if (basic_globals.locale_string) {
    if ((unsigned int )basic_globals.locale_string >= (unsigned int )compiler_globals.interned_strings_start) {
      if ((unsigned int )basic_globals.locale_string < (unsigned int )compiler_globals.interned_strings_end) {

      } else {
        _efree((void *)basic_globals.locale_string);
      }
    } else {
      _efree((void *)basic_globals.locale_string);
    }
  } else {

  }
  basic_globals.locale_string = (char *)((void *)0);
  zm_deactivate_filestat(type, module_number);
  tmp = strlen("assert");
  tmp___0 = zend_hash_exists((HashTable const   *)(& basic_submodules), "assert", tmp);
  if (tmp___0) {
    zm_deactivate_assert(type, module_number);
  } else {

  }
  tmp___1 = strlen("url_scanner_ex");
  tmp___2 = zend_hash_exists((HashTable const   *)(& basic_submodules), "url_scanner_ex", tmp___1);
  if (tmp___2) {
    zm_deactivate_url_scanner_ex(type, module_number);
  } else {

  }
  tmp___3 = strlen("streams");
  tmp___4 = zend_hash_exists((HashTable const   *)(& basic_submodules), "streams", tmp___3);
  if (tmp___4) {
    zm_deactivate_streams(type, module_number);
  } else {

  }
  if (basic_globals.user_tick_functions) {
    zend_llist_destroy(basic_globals.user_tick_functions);
    _efree((void *)basic_globals.user_tick_functions);
    basic_globals.user_tick_functions = (zend_llist *)((void *)0);
  } else {

  }
  tmp___5 = strlen("user_filters");
  tmp___6 = zend_hash_exists((HashTable const   *)(& basic_submodules), "user_filters", tmp___5);
  if (tmp___6) {
    zm_deactivate_user_filters(type, module_number);
  } else {

  }
  tmp___7 = strlen("browscap");
  tmp___8 = zend_hash_exists((HashTable const   *)(& basic_submodules), "browscap", tmp___7);
  if (tmp___8) {
    zm_deactivate_browscap(type, module_number);
  } else {

  }
  basic_globals.page_uid = -1L;
  basic_globals.page_gid = -1L;
  return (0);
}
}
void zm_info_basic(zend_module_entry *zend_module ) 
{ size_t tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  size_t tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  size_t tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;

  {
  php_info_print_table_start();
  tmp = strlen("dl");
  tmp___0 = zend_hash_exists((HashTable const   *)(& basic_submodules), "dl", tmp);
  if (tmp___0) {
    zm_info_dl(zend_module);
  } else {

  }
  tmp___1 = strlen("mail");
  tmp___2 = zend_hash_exists((HashTable const   *)(& basic_submodules), "mail", tmp___1);
  if (tmp___2) {
    zm_info_mail(zend_module);
  } else {

  }
  php_info_print_table_end();
  tmp___3 = strlen("assert");
  tmp___4 = zend_hash_exists((HashTable const   *)(& basic_submodules), "assert", tmp___3);
  if (tmp___4) {
    zm_info_assert(zend_module);
  } else {

  }
  return;
}
}
void zif_constant(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *const_name ;
  int const_name_len ;
  int __attribute__((__visibility__("default")))  tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  tmp = zend_parse_parameters(ht, "s", & const_name, & const_name_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_get_constant_ex((char const   *)const_name, (unsigned int )const_name_len, return_value, (zend_class_entry *)((void *)0), 256UL);
  if (tmp___0) {

  } else {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Couldn\'t find constant %s", const_name);
    return_value->type = (unsigned char)0;
    return;
  }
  return;
}
}
void php_inet_ntop(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *address ;
  int address_len ;
  int af ;
  char buffer[40] ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  zval *__z___1 ;
  char const   *tmp___0 ;
  char const   *__s ;
  zval *__z___2 ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  af = 2;
  tmp = zend_parse_parameters(ht, "s", & address, & address_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (address_len == 16) {
    af = 10;
  } else {
    if (address_len != 4) {
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid in_addr value");
      while (1) {
        __z___0 = return_value;
        __z___0->value.lval = 0L;
        __z___0->type = (unsigned char)3;
        break;
      }
      return;
    } else {

    }
  }
  tmp___0 = inet_ntop(af, (void const   */* __restrict  */)address, (char */* __restrict  */)(buffer), sizeof(buffer));
  if (tmp___0) {

  } else {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "An unknown error occured");
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  }
  while (1) {
    __s = (char const   *)(buffer);
    __z___2 = return_value;
    tmp___1 = strlen(__s);
    __z___2->value.str.len = (int )tmp___1;
    tmp___2 = _estrndup(__s, (unsigned int )__z___2->value.str.len);
    __z___2->value.str.val = (char *)tmp___2;
    __z___2->type = (unsigned char)6;
    break;
  }
  return;
}
}
void php_inet_pton(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ int ret ;
  int af ;
  char *address ;
  int address_len ;
  char buffer[17] ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  void *tmp___0 ;
  char *tmp___1 ;
  void *tmp___2 ;
  char *tmp___3 ;
  zval *__z___1 ;
  char const   *__s ;
  int __l ;
  int tmp___4 ;
  zval *__z___2 ;
  char __attribute__((__visibility__("default")))  *tmp___5 ;

  {
  af = 2;
  tmp = zend_parse_parameters(ht, "s", & address, & address_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  memset((void *)(buffer), 0, sizeof(buffer));
  tmp___3 = __builtin_strchr(address, ':');
  if (tmp___3) {
    af = 10;
  } else {
    tmp___1 = __builtin_strchr(address, '.');
    if (tmp___1) {

    } else {
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unrecognized address %s", address);
      while (1) {
        __z___0 = return_value;
        __z___0->value.lval = 0L;
        __z___0->type = (unsigned char)3;
        break;
      }
      return;
    }
  }
  ret = inet_pton(af, (char const   */* __restrict  */)address, (void */* __restrict  */)(buffer));
  if (ret <= 0) {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unrecognized address %s", address);
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __s = (char const   *)(buffer);
    if (af == 2) {
      tmp___4 = 4;
    } else {
      tmp___4 = 16;
    }
    __l = tmp___4;
    __z___2 = return_value;
    __z___2->value.str.len = __l;
    tmp___5 = _estrndup(__s, (unsigned int )__l);
    __z___2->value.str.val = (char *)tmp___5;
    __z___2->type = (unsigned char)6;
    break;
  }
  return;
}
}
void zif_ip2long(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *addr ;
  int addr_len ;
  struct in_addr ip ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  int tmp___0 ;
  zval *__z___0 ;
  register unsigned int __v ;
  register unsigned int __x ;

  {
  tmp = zend_parse_parameters(ht, "s", & addr, & addr_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (addr_len == 0) {
    goto _L;
  } else {
    tmp___0 = inet_pton(2, (char const   */* __restrict  */)addr, (void */* __restrict  */)(& ip));
    if (tmp___0 != 1) {
      _L: /* CIL Label */ 
      while (1) {
        __z = return_value;
        __z->value.lval = 0L;
        __z->type = (unsigned char)3;
        break;
      }
      return;
    } else {

    }
  }
  __z___0 = return_value;
  __x = ip.s_addr;
  __asm__  ("bswap %0": "=r" (__v): "0" (__x));
  __z___0->value.lval = (long )__v;
  __z___0->type = (unsigned char)1;
  return;
}
}
void zif_long2ip(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *ip ;
  int ip_len ;
  unsigned long n ;
  struct in_addr myaddr ;
  char str[40] ;
  int __attribute__((__visibility__("default")))  tmp ;
  register unsigned int __v ;
  register unsigned int __x ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;
  zval *__z___0 ;
  char const   *tmp___2 ;

  {
  tmp = zend_parse_parameters(ht, "s", & ip, & ip_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  n = strtoul((char const   */* __restrict  */)ip, (char **/* __restrict  */)((void *)0), 0);
  __x = (unsigned int )n;
  __asm__  ("bswap %0": "=r" (__v): "0" (__x));
  myaddr.s_addr = __v;
  tmp___2 = inet_ntop(2, (void const   */* __restrict  */)(& myaddr), (char */* __restrict  */)(str), sizeof(str));
  if (tmp___2) {
    while (1) {
      __s = (char const   *)(str);
      __z = return_value;
      tmp___0 = strlen(__s);
      __z->value.str.len = (int )tmp___0;
      tmp___1 = _estrndup(__s, (unsigned int )__z->value.str.len);
      __z->value.str.val = (char *)tmp___1;
      __z->type = (unsigned char)6;
      break;
    }
    return;
  } else {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  }
}
}
void zif_getenv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *ptr ;
  char *str ;
  int str_len ;
  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 ;
  char const   *__s___0 ;
  zval *__z___1 ;
  size_t tmp___3 ;
  char __attribute__((__visibility__("default")))  *tmp___4 ;
  zval *__z___2 ;

  {
  tmp = zend_parse_parameters(ht, "s", & str, & str_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp___0 = sapi_getenv(str, (unsigned int )str_len);
  ptr = (char *)tmp___0;
  if (ptr) {
    while (1) {
      __s = (char const   *)ptr;
      __z___0 = return_value;
      tmp___1 = strlen(__s);
      __z___0->value.str.len = (int )tmp___1;
      __z___0->value.str.val = (char *)((char __attribute__((__visibility__("default")))  *)((char *)__s));
      __z___0->type = (unsigned char)6;
      break;
    }
    return;
  } else {

  }
  ptr = getenv((char const   *)str);
  if (ptr) {
    while (1) {
      __s___0 = (char const   *)ptr;
      __z___1 = return_value;
      tmp___3 = strlen(__s___0);
      __z___1->value.str.len = (int )tmp___3;
      tmp___4 = _estrndup(__s___0, (unsigned int )__z___1->value.str.len);
      __z___1->value.str.val = (char *)tmp___4;
      __z___1->type = (unsigned char)6;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __z___2 = return_value;
    __z___2->value.lval = 0L;
    __z___2->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_putenv(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *setting ;
  int setting_len ;
  int __attribute__((__visibility__("default")))  tmp ;
  char *p ;
  char **env ;
  putenv_entry pe ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;
  void *tmp___2 ;
  char *tmp___3 ;
  size_t tmp___4 ;
  size_t tmp___5 ;
  size_t tmp___6 ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___10 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___11 ;
  int tmp___12 ;
  int tmp___13 ;
  int tmp___14 ;
  int tmp___15 ;
  size_t tmp___16 ;
  size_t tmp___17 ;
  size_t tmp___18 ;
  size_t tmp___19 ;
  size_t __s1_len___0 ;
  size_t __s2_len___0 ;
  int tmp___20 ;
  int tmp___21 ;
  int tmp___22 ;
  unsigned char const   *__s2___0 ;
  register int __result___1 ;
  int tmp___23 ;
  unsigned char const   *__s1___0 ;
  register int __result___2 ;
  int tmp___24 ;
  int tmp___25 ;
  int tmp___26 ;
  int tmp___27 ;
  int tmp___28 ;
  size_t tmp___29 ;
  size_t tmp___30 ;
  zval *__z ;
  zval *__z___0 ;
  int tmp___31 ;
  zval *__z___1 ;

  {
  tmp = zend_parse_parameters(ht, "s", & setting, & setting_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (setting_len) {
    tmp___0 = _estrndup((char const   *)setting, (unsigned int )setting_len);
    pe.putenv_string = (char *)tmp___0;
    tmp___1 = _estrndup((char const   *)setting, (unsigned int )setting_len);
    pe.key = (char *)tmp___1;
    tmp___3 = __builtin_strchr(pe.key, '=');
    p = tmp___3;
    if (p) {
      *p = (char )'\000';
    } else {

    }
    tmp___4 = strlen((char const   *)pe.key);
    pe.key_len = (int )tmp___4;
    zend_hash_del_key_or_index(& basic_globals.putenv_ht, (char const   *)pe.key, (unsigned int )(pe.key_len + 1), 0UL, 0);
    pe.previous_value = (char *)((void *)0);
    env = environ;
    while (1) {
      if ((unsigned int )env != (unsigned int )((void *)0)) {
        if ((unsigned int )*env != (unsigned int )((void *)0)) {

        } else {
          break;
        }
      } else {
        break;
      }
      if (0) {
        if (0) {
          __s1_len = strlen((char const   *)*env);
          __s2_len = strlen((char const   *)pe.key);
          if (! ((unsigned int )((void const   *)(*env + 1)) - (unsigned int )((void const   *)*env) == 1U)) {
            goto _L___0;
          } else {
            if (__s1_len >= 4U) {
              _L___0: /* CIL Label */ 
              if (! ((unsigned int )((void const   *)(pe.key + 1)) - (unsigned int )((void const   *)pe.key) == 1U)) {
                tmp___13 = 1;
              } else {
                if (__s2_len >= 4U) {
                  tmp___13 = 1;
                } else {
                  tmp___13 = 0;
                }
              }
            } else {
              tmp___13 = 0;
            }
          }
          if (tmp___13) {
            tmp___8 = __builtin_strcmp((char const   *)*env, (char const   *)pe.key);
            tmp___12 = tmp___8;
          } else {
            tmp___11 = __builtin_strcmp((char const   *)*env, (char const   *)pe.key);
            tmp___12 = tmp___11;
          }
        } else {
          tmp___11 = __builtin_strcmp((char const   *)*env, (char const   *)pe.key);
          tmp___12 = tmp___11;
        }
        tmp___15 = tmp___12;
      } else {
        tmp___14 = strncmp((char const   *)*env, (char const   *)pe.key, (unsigned int )pe.key_len);
        tmp___15 = tmp___14;
      }
      if (tmp___15) {

      } else {
        if ((int )*(*env + pe.key_len) == 61) {
          pe.previous_value = *env;
          break;
        } else {

        }
      }
      env ++;
    }
    if (! p) {
      unsetenv((char const   *)pe.putenv_string);
    } else {

    }
    if (! p) {
      goto _L___3;
    } else {
      tmp___31 = putenv(pe.putenv_string);
      if (tmp___31 == 0) {
        _L___3: /* CIL Label */ 
        _zend_hash_add_or_update(& basic_globals.putenv_ht, (char const   *)pe.key, (unsigned int )(pe.key_len + 1), (void *)((void **)(& pe)), sizeof(putenv_entry ), (void **)((void *)0), 1 << 1);
        if (0) {
          if (0) {
            __s1_len___0 = strlen((char const   *)pe.key);
            __s2_len___0 = strlen("TZ");
            if (! ((unsigned int )((void const   *)(pe.key + 1)) - (unsigned int )((void const   *)pe.key) == 1U)) {
              goto _L___2;
            } else {
              if (__s1_len___0 >= 4U) {
                _L___2: /* CIL Label */ 
                if (! ((unsigned int )((void const   *)("TZ" + 1)) - (unsigned int )((void const   *)"TZ") == 1U)) {
                  tmp___26 = 1;
                } else {
                  if (__s2_len___0 >= 4U) {
                    tmp___26 = 1;
                  } else {
                    tmp___26 = 0;
                  }
                }
              } else {
                tmp___26 = 0;
              }
            }
            if (tmp___26) {
              tmp___21 = __builtin_strcmp((char const   *)pe.key, "TZ");
              tmp___25 = tmp___21;
            } else {
              tmp___24 = __builtin_strcmp((char const   *)pe.key, "TZ");
              tmp___25 = tmp___24;
            }
          } else {
            tmp___24 = __builtin_strcmp((char const   *)pe.key, "TZ");
            tmp___25 = tmp___24;
          }
          tmp___28 = tmp___25;
        } else {
          tmp___27 = strncmp((char const   *)pe.key, "TZ", (unsigned int )pe.key_len);
          tmp___28 = tmp___27;
        }
        if (tmp___28) {

        } else {
          tzset();
        }
        while (1) {
          __z = return_value;
          __z->value.lval = 1L;
          __z->type = (unsigned char)3;
          break;
        }
        return;
      } else {
        _efree((void *)pe.putenv_string);
        _efree((void *)pe.key);
        while (1) {
          __z___0 = return_value;
          __z___0->value.lval = 0L;
          __z___0->type = (unsigned char)3;
          break;
        }
        return;
      }
    }
  } else {

  }
  php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid parameter syntax");
  while (1) {
    __z___1 = return_value;
    __z___1->value.lval = 0L;
    __z___1->type = (unsigned char)3;
    break;
  }
  return;
}
}
static void free_argv(char **argv , int argc ) 
{ int i ;

  {
  if (argv) {
    i = 0;
    while (i < argc) {
      if (*(argv + i)) {
        _efree((void *)*(argv + i));
      } else {

      }
      i ++;
    }
    _efree((void *)argv);
  } else {

  }
  return;
}
}
static void free_longopts(opt_struct *longopts ) 
{ opt_struct *p ;

  {
  if (longopts) {
    p = longopts;
    while (1) {
      if (p) {
        if ((int )p->opt_char != 45) {

        } else {
          break;
        }
      } else {
        break;
      }
      if ((unsigned int )p->opt_name != (unsigned int )((void *)0)) {
        _efree((void *)p->opt_name);
      } else {

      }
      p ++;
    }
  } else {

  }
  return;
}
}
static int parse_opts(char *opts , opt_struct **result ) 
{ opt_struct *paras ;
  unsigned int i ;
  unsigned int count ;
  size_t tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  paras = (opt_struct *)((void *)0);
  count = 0U;
  i = 0U;
  while (1) {
    tmp = strlen((char const   *)opts);
    if (i < tmp) {

    } else {
      break;
    }
    if ((int )*(opts + i) >= 48) {
      if ((int )*(opts + i) <= 57) {
        count ++;
      } else {
        goto _L___0;
      }
    } else {
      _L___0: /* CIL Label */ 
      if ((int )*(opts + i) >= 65) {
        if ((int )*(opts + i) <= 90) {
          count ++;
        } else {
          goto _L;
        }
      } else {
        _L: /* CIL Label */ 
        if ((int )*(opts + i) >= 97) {
          if ((int )*(opts + i) <= 122) {
            count ++;
          } else {

          }
        } else {

        }
      }
    }
    i ++;
  }
  tmp___0 = _safe_emalloc(sizeof(opt_struct ), count, 0U);
  paras = (opt_struct *)tmp___0;
  memset((void *)paras, 0, sizeof(opt_struct ) * count);
  *result = paras;
  while (1) {
    if ((int )*opts >= 48) {
      if ((int )*opts <= 57) {

      } else {
        goto _L___2;
      }
    } else {
      _L___2: /* CIL Label */ 
      if ((int )*opts >= 65) {
        if ((int )*opts <= 90) {

        } else {
          goto _L___1;
        }
      } else {
        _L___1: /* CIL Label */ 
        if ((int )*opts >= 97) {
          if ((int )*opts <= 122) {

          } else {
            break;
          }
        } else {
          break;
        }
      }
    }
    paras->opt_char = *opts;
    opts ++;
    if ((int )*opts == 58) {
      paras->need_param = 1;
    } else {
      paras->need_param = 0;
    }
    paras->opt_name = (char *)((void *)0);
    if (paras->need_param == 1) {
      opts ++;
      if ((int )*opts == 58) {
        (paras->need_param) ++;
        opts ++;
      } else {

      }
    } else {

    }
    paras ++;
  }
  return ((int )count);
}
}
void zif_getopt(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *options ;
  char **argv ;
  char opt[2] ;
  char *optname ;
  int argc ;
  int options_len ;
  int len ;
  int o ;
  char *php_optarg ;
  int php_optind ;
  zval *val ;
  zval **args ;
  zval *p_longopts ;
  int optname_len ;
  opt_struct *opts ;
  opt_struct *orig_opts ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  int pos ;
  zval **entry ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zval arg ;
  zval *arg_ptr ;
  int tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  zval *__z___0 ;
  HashTable *tmp___5 ;
  HashTable *tmp___6 ;
  HashTable *tmp___7 ;
  int __attribute__((__visibility__("default")))  tmp___8 ;
  int __attribute__((__visibility__("default")))  tmp___9 ;
  int count ;
  zval **entry___0 ;
  int __attribute__((__visibility__("default")))  tmp___10 ;
  void __attribute__((__visibility__("default")))  *tmp___11 ;
  zval arg___0 ;
  zval *arg_ptr___0 ;
  char __attribute__((__visibility__("default")))  *tmp___12 ;
  size_t tmp___13 ;
  int __attribute__((__visibility__("default")))  tmp___14 ;
  void __attribute__((__visibility__("default")))  *tmp___15 ;
  void __attribute__((__visibility__("default")))  *tmp___16 ;
  char const   *__s ;
  zval *__z___1 ;
  size_t tmp___17 ;
  char __attribute__((__visibility__("default")))  *tmp___18 ;
  zval *__z___2 ;
  size_t tmp___19 ;
  int optname_int ;
  int tmp___20 ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___21 ;
  zend_uint tmp___22 ;
  zend_bool tmp___23 ;
  HashTable *tmp___24 ;
  HashTable *tmp___25 ;
  HashTable *tmp___26 ;
  HashTable *tmp___27 ;
  HashTable *tmp___28 ;
  HashTable *tmp___29 ;
  HashTable *tmp___30 ;
  HashTable *tmp___31 ;
  HashTable *tmp___32 ;
  int __attribute__((__visibility__("default")))  tmp___33 ;
  zval *new_zv___0 ;
  void __attribute__((__visibility__("default")))  *tmp___34 ;
  zend_uint tmp___35 ;
  zend_bool tmp___36 ;
  HashTable *tmp___37 ;
  HashTable *tmp___38 ;
  HashTable *tmp___39 ;
  size_t tmp___40 ;
  HashTable *tmp___41 ;
  HashTable *tmp___42 ;
  HashTable *tmp___43 ;
  size_t tmp___44 ;
  HashTable *tmp___45 ;
  HashTable *tmp___46 ;
  HashTable *tmp___47 ;
  int __attribute__((__visibility__("default")))  tmp___48 ;
  zend_uchar tmp___49 ;
  int __attribute__((__visibility__("default")))  tmp___50 ;

  {
  options = (char *)((void *)0);
  argv = (char **)((void *)0);
  opt[0] = (char )'\000';
  opt[1] = (char)0;
  argc = 0;
  options_len = 0;
  php_optarg = (char *)((void *)0);
  php_optind = 1;
  args = (zval **)((void *)0);
  p_longopts = (zval *)((void *)0);
  optname_len = 0;
  tmp = zend_parse_parameters(ht, "s|a", & options, & options_len, & p_longopts);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (core_globals.http_globals[3]) {
    if ((int )(core_globals.http_globals[3])->type == 4) {
      tmp___7 = (core_globals.http_globals[3])->value.ht;
    } else {
      if ((int )(core_globals.http_globals[3])->type == 5) {
        tmp___5 = (*(((core_globals.http_globals[3])->value.obj.handlers)->get_properties))(core_globals.http_globals[3]);
        tmp___6 = tmp___5;
      } else {
        tmp___6 = (HashTable *)((void *)0);
      }
      tmp___7 = tmp___6;
    }
    tmp___8 = zend_hash_find((HashTable const   *)tmp___7, "argv", sizeof("argv"), (void **)(& args));
    if (tmp___8 != (int __attribute__((__visibility__("default")))  )-1) {
      goto _L___1;
    } else {
      tmp___9 = zend_hash_find((HashTable const   *)(& executor_globals.symbol_table), "argv", sizeof("argv"), (void **)(& args));
      if (tmp___9 != (int __attribute__((__visibility__("default")))  )-1) {
        _L___1: /* CIL Label */ 
        if ((int )(*args)->type == 4) {
          pos = 0;
          tmp___0 = zend_hash_num_elements((HashTable const   *)(*args)->value.ht);
          argc = (int )tmp___0;
          tmp___1 = _safe_emalloc(sizeof(char *), (unsigned int )(argc + 1), 0U);
          argv = (char **)tmp___1;
          zend_hash_internal_pointer_reset_ex((*args)->value.ht, (HashPosition *)((void *)0));
          while (1) {
            tmp___4 = zend_hash_get_current_data_ex((*args)->value.ht, (void **)(& entry), (HashPosition *)((void *)0));
            if (tmp___4 == (int __attribute__((__visibility__("default")))  )0) {

            } else {
              break;
            }
            arg_ptr = *entry;
            if ((int )(*entry)->type != 6) {
              arg = *(*entry);
              _zval_copy_ctor(& arg);
              if ((int )arg.type != 6) {
                _convert_to_string(& arg);
              } else {

              }
              arg_ptr = & arg;
            } else {

            }
            tmp___2 = pos;
            pos ++;
            tmp___3 = _estrdup((char const   *)arg_ptr->value.str.val);
            *(argv + tmp___2) = (char *)tmp___3;
            if ((unsigned int )arg_ptr != (unsigned int )*entry) {
              _zval_dtor(& arg);
            } else {

            }
            zend_hash_move_forward_ex((*args)->value.ht, (HashPosition *)((void *)0));
          }
          *(argv + argc) = (char *)((void *)0);
        } else {
          goto _L___0;
        }
      } else {
        goto _L___0;
      }
    }
  } else {
    _L___0: /* CIL Label */ 
    _L: /* CIL Label */ 
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  }
  len = parse_opts(options, & opts);
  if (p_longopts) {
    tmp___10 = zend_hash_num_elements((HashTable const   *)p_longopts->value.ht);
    count = (int )tmp___10;
    tmp___11 = _erealloc((void *)opts, sizeof(opt_struct ) * (unsigned int )((len + count) + 1), 0);
    opts = (opt_struct *)tmp___11;
    orig_opts = opts;
    opts += len;
    memset((void *)opts, 0, (unsigned int )count * sizeof(opt_struct ));
    zend_hash_internal_pointer_reset_ex(p_longopts->value.ht, (HashPosition *)((void *)0));
    while (1) {
      tmp___14 = zend_hash_get_current_data_ex(p_longopts->value.ht, (void **)(& entry___0), (HashPosition *)((void *)0));
      if (tmp___14 == (int __attribute__((__visibility__("default")))  )0) {

      } else {
        break;
      }
      arg_ptr___0 = *entry___0;
      if ((int )(*entry___0)->type != 6) {
        arg___0 = *(*entry___0);
        _zval_copy_ctor(& arg___0);
        if ((int )arg___0.type != 6) {
          _convert_to_string(& arg___0);
        } else {

        }
        arg_ptr___0 = & arg___0;
      } else {

      }
      opts->need_param = 0;
      tmp___12 = _estrdup((char const   *)arg_ptr___0->value.str.val);
      opts->opt_name = (char *)tmp___12;
      tmp___13 = strlen((char const   *)opts->opt_name);
      len = (int )tmp___13;
      if (len > 0) {
        if ((int )*(opts->opt_name + (len - 1)) == 58) {
          (opts->need_param) ++;
          *(opts->opt_name + (len - 1)) = (char )'\000';
          if (len > 1) {
            if ((int )*(opts->opt_name + (len - 2)) == 58) {
              (opts->need_param) ++;
              *(opts->opt_name + (len - 2)) = (char )'\000';
            } else {

            }
          } else {

          }
        } else {

        }
      } else {

      }
      opts->opt_char = (char)0;
      opts ++;
      if ((unsigned int )arg_ptr___0 != (unsigned int )*entry___0) {
        _zval_dtor(& arg___0);
      } else {

      }
      zend_hash_move_forward_ex(p_longopts->value.ht, (HashPosition *)((void *)0));
    }
  } else {
    tmp___15 = _erealloc((void *)opts, sizeof(opt_struct ) * (unsigned int )(len + 1), 0);
    opts = (opt_struct *)tmp___15;
    orig_opts = opts;
    opts += len;
  }
  opts->opt_char = (char )'-';
  opts->need_param = 0;
  opts->opt_name = (char *)((void *)0);
  _array_init(return_value, 0U);
  opts = orig_opts;
  while (1) {
    tmp___50 = php_getopt(argc, (char * const  *)argv, (opt_struct const   *)opts, & php_optarg, & php_optind, 0, 1);
    o = (int )tmp___50;
    if (o != -1) {

    } else {
      break;
    }
    if (o == 63) {
      continue;
    } else {

    }
    if (o == 0) {
      optname = (opts + php_optidx)->opt_name;
    } else {
      if (o == 1) {
        o = '-';
      } else {

      }
      opt[0] = (char )o;
      optname = opt;
    }
    while (1) {
      tmp___16 = _emalloc(sizeof(zval_gc_info ));
      val = (zval *)tmp___16;
      ((zval_gc_info *)val)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    val->refcount__gc = 1U;
    val->is_ref__gc = (unsigned char)0;
    if ((unsigned int )php_optarg != (unsigned int )((void *)0)) {
      while (1) {
        __s = (char const   *)php_optarg;
        __z___1 = val;
        tmp___17 = strlen(__s);
        __z___1->value.str.len = (int )tmp___17;
        tmp___18 = _estrndup(__s, (unsigned int )__z___1->value.str.len);
        __z___1->value.str.val = (char *)tmp___18;
        __z___1->type = (unsigned char)6;
        break;
      }
    } else {
      while (1) {
        __z___2 = val;
        __z___2->value.lval = 0L;
        __z___2->type = (unsigned char)3;
        break;
      }
    }
    tmp___19 = strlen((char const   *)optname);
    optname_len = (int )tmp___19;
    if (optname_len > 1) {
      if ((int )*(optname + 0) == 48) {
        _L___2: /* CIL Label */ 
        tmp___44 = strlen((char const   *)optname);
        if ((int )return_value->type == 4) {
          tmp___47 = return_value->value.ht;
        } else {
          if ((int )return_value->type == 5) {
            tmp___45 = (*((return_value->value.obj.handlers)->get_properties))(return_value);
            tmp___46 = tmp___45;
          } else {
            tmp___46 = (HashTable *)((void *)0);
          }
          tmp___47 = tmp___46;
        }
        tmp___48 = zend_hash_find((HashTable const   *)tmp___47, (char const   *)optname, tmp___44 + 1U, (void **)(& args));
        if (tmp___48 != (int __attribute__((__visibility__("default")))  )-1) {
          if ((int )(*args)->type != 4) {
            if ((int )(*args)->type != 4) {
              tmp___36 = zval_isref_p(*args);
              if (tmp___36) {

              } else {
                while (1) {
                  tmp___35 = zval_refcount_p(*args);
                  if (tmp___35 > 1U) {
                    zval_delref_p(*args);
                    while (1) {
                      tmp___34 = _emalloc(sizeof(zval_gc_info ));
                      new_zv___0 = (zval *)tmp___34;
                      ((zval_gc_info *)new_zv___0)->u.buffered = (gc_root_buffer *)((void *)0);
                      break;
                    }
                    while (1) {
                      while (1) {
                        new_zv___0->value = (*args)->value;
                        new_zv___0->type = (*args)->type;
                        break;
                      }
                      zval_set_refcount_p(new_zv___0, 1U);
                      zval_unset_isref_p(new_zv___0);
                      break;
                    }
                    *args = new_zv___0;
                    _zval_copy_ctor(new_zv___0);
                  } else {

                  }
                  break;
                }
              }
              convert_to_array(*args);
            } else {

            }
          } else {

          }
          if ((int )(*args)->type == 4) {
            tmp___39 = (*args)->value.ht;
          } else {
            if ((int )(*args)->type == 5) {
              tmp___37 = (*(((*args)->value.obj.handlers)->get_properties))(*args);
              tmp___38 = tmp___37;
            } else {
              tmp___38 = (HashTable *)((void *)0);
            }
            tmp___39 = tmp___38;
          }
          _zend_hash_index_update_or_next_insert(tmp___39, 0UL, (void *)(& val), sizeof(zval *), (void **)((void *)0), 1 << 2);
        } else {
          tmp___40 = strlen((char const   *)optname);
          if ((int )return_value->type == 4) {
            tmp___43 = return_value->value.ht;
          } else {
            if ((int )return_value->type == 5) {
              tmp___41 = (*((return_value->value.obj.handlers)->get_properties))(return_value);
              tmp___42 = tmp___41;
            } else {
              tmp___42 = (HashTable *)((void *)0);
            }
            tmp___43 = tmp___42;
          }
          _zend_hash_add_or_update(tmp___43, (char const   *)optname, tmp___40 + 1U, (void *)(& val), sizeof(zval *), (void **)((void *)0), 1 << 1);
        }
      } else {
        goto _L___3;
      }
    } else {
      _L___3: /* CIL Label */ 
      tmp___49 = is_numeric_string((char const   *)optname, optname_len, (long *)((void *)0), (double *)((void *)0), 0);
      if ((int )tmp___49 == 1) {
        tmp___20 = atoi((char const   *)optname);
        optname_int = tmp___20;
        if ((int )return_value->type == 4) {
          tmp___32 = return_value->value.ht;
        } else {
          if ((int )return_value->type == 5) {
            tmp___30 = (*((return_value->value.obj.handlers)->get_properties))(return_value);
            tmp___31 = tmp___30;
          } else {
            tmp___31 = (HashTable *)((void *)0);
          }
          tmp___32 = tmp___31;
        }
        tmp___33 = zend_hash_index_find((HashTable const   *)tmp___32, (unsigned long )optname_int, (void **)(& args));
        if (tmp___33 != (int __attribute__((__visibility__("default")))  )-1) {
          if ((int )(*args)->type != 4) {
            if ((int )(*args)->type != 4) {
              tmp___23 = zval_isref_p(*args);
              if (tmp___23) {

              } else {
                while (1) {
                  tmp___22 = zval_refcount_p(*args);
                  if (tmp___22 > 1U) {
                    zval_delref_p(*args);
                    while (1) {
                      tmp___21 = _emalloc(sizeof(zval_gc_info ));
                      new_zv = (zval *)tmp___21;
                      ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
                      break;
                    }
                    while (1) {
                      while (1) {
                        new_zv->value = (*args)->value;
                        new_zv->type = (*args)->type;
                        break;
                      }
                      zval_set_refcount_p(new_zv, 1U);
                      zval_unset_isref_p(new_zv);
                      break;
                    }
                    *args = new_zv;
                    _zval_copy_ctor(new_zv);
                  } else {

                  }
                  break;
                }
              }
              convert_to_array(*args);
            } else {

            }
          } else {

          }
          if ((int )(*args)->type == 4) {
            tmp___26 = (*args)->value.ht;
          } else {
            if ((int )(*args)->type == 5) {
              tmp___24 = (*(((*args)->value.obj.handlers)->get_properties))(*args);
              tmp___25 = tmp___24;
            } else {
              tmp___25 = (HashTable *)((void *)0);
            }
            tmp___26 = tmp___25;
          }
          _zend_hash_index_update_or_next_insert(tmp___26, 0UL, (void *)(& val), sizeof(zval *), (void **)((void *)0), 1 << 2);
        } else {
          if ((int )return_value->type == 4) {
            tmp___29 = return_value->value.ht;
          } else {
            if ((int )return_value->type == 5) {
              tmp___27 = (*((return_value->value.obj.handlers)->get_properties))(return_value);
              tmp___28 = tmp___27;
            } else {
              tmp___28 = (HashTable *)((void *)0);
            }
            tmp___29 = tmp___28;
          }
          _zend_hash_index_update_or_next_insert(tmp___29, (unsigned long )optname_int, (void *)(& val), sizeof(zval *), (void **)((void *)0), 1);
        }
      } else {
        goto _L___2;
      }
    }
    php_optarg = (char *)((void *)0);
  }
  free_longopts(orig_opts);
  _efree((void *)orig_opts);
  free_argv(argv, argc);
  return;
}
}
void zif_flush(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ 

  {
  sapi_flush();
  return;
}
}
void zif_sleep(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ long num ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  zval *__z___1 ;
  unsigned int tmp___0 ;

  {
  tmp = zend_parse_parameters(ht, "l", & num);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (num < 0L) {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Number of seconds must be greater than or equal to 0");
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  __z___1 = return_value;
  tmp___0 = sleep((unsigned int )num);
  __z___1->value.lval = (long )tmp___0;
  __z___1->type = (unsigned char)1;
  return;
}
}
void zif_usleep(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ long num ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;

  {
  tmp = zend_parse_parameters(ht, "l", & num);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (num < 0L) {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Number of microseconds must be greater than or equal to 0");
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  usleep((unsigned int )num);
  return;
}
}
void zif_time_nanosleep(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ long tv_sec ;
  long tv_nsec ;
  struct timespec php_req ;
  struct timespec php_rem ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  int *tmp___0 ;
  int *tmp___1 ;
  int tmp___2 ;
  zval *__z___0 ;

  {
  tmp = zend_parse_parameters(ht, "ll", & tv_sec, & tv_nsec);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  php_req.tv_sec = tv_sec;
  php_req.tv_nsec = tv_nsec;
  tmp___2 = nanosleep((struct timespec  const  *)(& php_req), & php_rem);
  if (tmp___2) {
    tmp___1 = __errno_location();
    if (*tmp___1 == 4) {
      _array_init(return_value, 0U);
      add_assoc_long_ex(return_value, "seconds", sizeof("seconds"), php_rem.tv_sec);
      add_assoc_long_ex(return_value, "nanoseconds", sizeof("nanoseconds"), php_rem.tv_nsec);
      return;
    } else {
      tmp___0 = __errno_location();
      if (*tmp___0 == 22) {
        php_error_docref0((char const   *)((void *)0), 1 << 1L, "nanoseconds was not in the range 0 to 999 999 999 or seconds was negative");
      } else {

      }
    }
  } else {
    while (1) {
      __z = return_value;
      __z->value.lval = 1L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  }
  while (1) {
    __z___0 = return_value;
    __z___0->value.lval = 0L;
    __z___0->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_time_sleep_until(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ double d_ts ;
  double c_ts ;
  struct timeval tm ;
  struct timespec php_req ;
  struct timespec php_rem ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  int tmp___0 ;
  zval *__z___0 ;
  zval *__z___1 ;
  int *tmp___1 ;
  int tmp___2 ;
  zval *__z___2 ;

  {
  tmp = zend_parse_parameters(ht, "d", & d_ts);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = gettimeofday((struct timeval */* __restrict  */)(& tm), (struct timezone */* __restrict  */)((void *)0));
  if (tmp___0 != 0) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  c_ts = (d_ts - (double )tm.tv_sec) - (double )tm.tv_usec / 1000000.00;
  if (c_ts < (double )0) {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Sleep until to time is less than current time");
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  php_req.tv_sec = (long )c_ts;
  if ((double )php_req.tv_sec > c_ts) {
    (php_req.tv_sec) --;
  } else {

  }
  php_req.tv_nsec = (long )((c_ts - (double )php_req.tv_sec) * 1000000000.00);
  while (1) {
    tmp___2 = nanosleep((struct timespec  const  *)(& php_req), & php_rem);
    if (tmp___2) {

    } else {
      break;
    }
    tmp___1 = __errno_location();
    if (*tmp___1 == 4) {
      php_req.tv_sec = php_rem.tv_sec;
      php_req.tv_nsec = php_rem.tv_nsec;
    } else {
      while (1) {
        __z___1 = return_value;
        __z___1->value.lval = 0L;
        __z___1->type = (unsigned char)3;
        break;
      }
      return;
    }
  }
  while (1) {
    __z___2 = return_value;
    __z___2->value.lval = 1L;
    __z___2->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_get_current_user(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ int __attribute__((__visibility__("default")))  tmp ;
  char const   *__s ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  while (1) {
    tmp___0 = php_get_current_user();
    __s = (char const   *)tmp___0;
    __z = return_value;
    tmp___1 = strlen(__s);
    __z->value.str.len = (int )tmp___1;
    tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
    __z->value.str.val = (char *)tmp___2;
    __z->type = (unsigned char)6;
    break;
  }
  return;
}
}
static int add_config_entry_cb(zval *entry , int num_args , va_list args , zend_hash_key *hash_key ) 
{ zval *retval ;
  zval *tmp ;
  zval *tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  tmp = __builtin_va_arg(args, zval *);
  retval = tmp;
  if ((int )entry->type == 6) {
    if (hash_key->nKeyLength > 0U) {
      add_assoc_stringl_ex(retval, hash_key->arKey, hash_key->nKeyLength, entry->value.str.val, (unsigned int )entry->value.str.len, 1);
    } else {
      add_index_stringl(retval, hash_key->h, (char const   *)entry->value.str.val, (unsigned int )entry->value.str.len, 1);
    }
  } else {
    if ((int )entry->type == 4) {
      while (1) {
        tmp___1 = _emalloc(sizeof(zval_gc_info ));
        tmp___0 = (zval *)tmp___1;
        ((zval_gc_info *)tmp___0)->u.buffered = (gc_root_buffer *)((void *)0);
        break;
      }
      tmp___0->refcount__gc = 1U;
      tmp___0->is_ref__gc = (unsigned char)0;
      _array_init(tmp___0, 0U);
      zend_hash_apply_with_arguments(entry->value.ht, (int (*)(void *pDest , int num_args , va_list args , zend_hash_key *hash_key ))(& add_config_entry_cb), 1, tmp___0);
      add_assoc_zval_ex(retval, hash_key->arKey, hash_key->nKeyLength, tmp___0);
    } else {

    }
  }
  return (0);
}
}
void zif_get_cfg_var(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *varname ;
  int varname_len ;
  zval *retval ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;
  zval *__z___0 ;

  {
  tmp = zend_parse_parameters(ht, "s", & varname, & varname_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = cfg_get_entry((char const   *)varname, (unsigned int )(varname_len + 1));
  retval = (zval *)tmp___0;
  if (retval) {
    if ((int )retval->type == 4) {
      _array_init(return_value, 0U);
      zend_hash_apply_with_arguments(retval->value.ht, (int (*)(void *pDest , int num_args , va_list args , zend_hash_key *hash_key ))(& add_config_entry_cb), 1, return_value);
      return;
    } else {
      while (1) {
        __s = (char const   *)retval->value.str.val;
        __z = return_value;
        tmp___1 = strlen(__s);
        __z->value.str.len = (int )tmp___1;
        tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
        __z->value.str.val = (char *)tmp___2;
        __z->type = (unsigned char)6;
        break;
      }
      return;
    }
  } else {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  }
}
}
void zif_set_magic_quotes_runtime(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zend_bool new_setting ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;

  {
  tmp = zend_parse_parameters(ht, "b", & new_setting);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (new_setting) {
    php_error_docref0((char const   *)((void *)0), 1 << 4L, "magic_quotes_runtime is not supported anymore");
  } else {

  }
  while (1) {
    __z = return_value;
    __z->value.lval = 0L;
    __z->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_get_magic_quotes_runtime(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  while (1) {
    __z = return_value;
    __z->value.lval = 0L;
    __z->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_get_magic_quotes_gpc(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  while (1) {
    __z = return_value;
    __z->value.lval = 0L;
    __z->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_error_log(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *message ;
  char *opt ;
  char *headers ;
  int message_len ;
  int opt_len ;
  int headers_len ;
  int opt_err ;
  int argc ;
  long erropt ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval *__z___0 ;

  {
  opt = (char *)((void *)0);
  headers = (char *)((void *)0);
  opt_len = 0;
  headers_len = 0;
  opt_err = 0;
  argc = ht;
  erropt = 0L;
  tmp = zend_parse_parameters(argc, "s|lps", & message, & message_len, & erropt, & opt, & opt_len, & headers, & headers_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (argc > 1) {
    opt_err = (int )erropt;
  } else {

  }
  tmp___0 = _php_error_log_ex(opt_err, message, message_len, opt, headers);
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __z___0 = return_value;
    __z___0->value.lval = 1L;
    __z___0->type = (unsigned char)3;
    break;
  }
  return;
}
}
int __attribute__((__visibility__("default")))  _php_error_log(int opt_err , char *message , char *opt , char *headers ) 
{ size_t tmp ;
  size_t tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  if (opt_err == 3) {
    tmp = strlen((char const   *)message);
    tmp___0 = tmp;
  } else {
    tmp___0 = 0U;
  }
  tmp___1 = _php_error_log_ex(opt_err, message, (int )tmp___0, opt, headers);
  return (tmp___1);
}
}
int __attribute__((__visibility__("default")))  _php_error_log_ex(int opt_err , char *message , int message_len , char *opt , char *headers ) 
{ php_stream *stream ;
  int __attribute__((__visibility__("default")))  tmp ;
  php_stream __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  stream = (php_stream *)((void *)0);
  switch (opt_err) {
  case 1: 
  tmp = php_mail(opt, (char *)"PHP error_log message", message, headers, (char *)((void *)0));
  if (tmp) {

  } else {
    return ((int __attribute__((__visibility__("default")))  )-1);
  }
  break;
  case 2: 
  php_error_docref0((char const   *)((void *)0), 1 << 1L, "TCP/IP option not available!");
  return ((int __attribute__((__visibility__("default")))  )-1);
  break;
  case 3: 
  tmp___0 = _php_stream_open_wrapper_ex(opt, (char *)"a", 8, (char **)((void *)0), (php_stream_context *)((void *)0));
  stream = (php_stream *)tmp___0;
  if (! stream) {
    return ((int __attribute__((__visibility__("default")))  )-1);
  } else {

  }
  _php_stream_write(stream, (char const   *)message, (unsigned int )message_len);
  _php_stream_free(stream, 3);
  break;
  case 4: 
  if (sapi_module.log_message) {
    (*(sapi_module.log_message))(message);
  } else {
    return ((int __attribute__((__visibility__("default")))  )-1);
  }
  break;
  default: 
  php_log_err(message);
  break;
  }
  return ((int __attribute__((__visibility__("default")))  )0);
}
}
void zif_error_get_last(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ int __attribute__((__visibility__("default")))  tmp ;
  char const   *tmp___0 ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (core_globals.last_error_message) {
    _array_init(return_value, 0U);
    add_assoc_long_ex(return_value, "type", sizeof("type"), (long )core_globals.last_error_type);
    add_assoc_string_ex(return_value, "message", sizeof("message"), core_globals.last_error_message, 1);
    if (core_globals.last_error_file) {
      tmp___0 = (char const   *)core_globals.last_error_file;
    } else {
      tmp___0 = "-";
    }
    add_assoc_string_ex(return_value, "file", sizeof("file"), (char *)tmp___0, 1);
    add_assoc_long_ex(return_value, "line", sizeof("line"), (long )core_globals.last_error_lineno);
  } else {

  }
  return;
}
}
void zif_call_user_func(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *retval_ptr ;
  zend_fcall_info fci ;
  zend_fcall_info_cache fci_cache ;
  int __attribute__((__visibility__("default")))  tmp ;
  zend_uint tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  retval_ptr = (zval *)((void *)0);
  tmp = zend_parse_parameters(ht, "f*", & fci, & fci_cache, & fci.params, & fci.param_count);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  fci.retval_ptr_ptr = & retval_ptr;
  tmp___1 = zend_call_function(& fci, & fci_cache);
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
    if (fci.retval_ptr_ptr) {
      if (*(fci.retval_ptr_ptr)) {
        *return_value = *(*(fci.retval_ptr_ptr));
        tmp___0 = zval_refcount_p(*(fci.retval_ptr_ptr));
        if (tmp___0 > 1U) {
          _zval_copy_ctor(return_value);
          zval_delref_p(*(fci.retval_ptr_ptr));
        } else {
          while (1) {
            if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)*(fci.retval_ptr_ptr))->u.buffered & 4294967292UL)) {
              gc_remove_zval_from_buffer(*(fci.retval_ptr_ptr));
            } else {

            }
            _efree((void *)*(fci.retval_ptr_ptr));
            break;
          }
        }
        return_value->refcount__gc = 1U;
        return_value->is_ref__gc = (unsigned char)0;
      } else {

      }
    } else {

    }
  } else {

  }
  if (fci.params) {
    _efree((void *)fci.params);
  } else {

  }
  return;
}
}
void zif_call_user_func_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *params ;
  zval *retval_ptr ;
  zend_fcall_info fci ;
  zend_fcall_info_cache fci_cache ;
  int __attribute__((__visibility__("default")))  tmp ;
  zend_uint tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  retval_ptr = (zval *)((void *)0);
  tmp = zend_parse_parameters(ht, "fa/", & fci, & fci_cache, & params);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  zend_fcall_info_args(& fci, params);
  fci.retval_ptr_ptr = & retval_ptr;
  tmp___1 = zend_call_function(& fci, & fci_cache);
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
    if (fci.retval_ptr_ptr) {
      if (*(fci.retval_ptr_ptr)) {
        *return_value = *(*(fci.retval_ptr_ptr));
        tmp___0 = zval_refcount_p(*(fci.retval_ptr_ptr));
        if (tmp___0 > 1U) {
          _zval_copy_ctor(return_value);
          zval_delref_p(*(fci.retval_ptr_ptr));
        } else {
          while (1) {
            if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)*(fci.retval_ptr_ptr))->u.buffered & 4294967292UL)) {
              gc_remove_zval_from_buffer(*(fci.retval_ptr_ptr));
            } else {

            }
            _efree((void *)*(fci.retval_ptr_ptr));
            break;
          }
        }
        return_value->refcount__gc = 1U;
        return_value->is_ref__gc = (unsigned char)0;
      } else {

      }
    } else {

    }
  } else {

  }
  zend_fcall_info_args_clear(& fci, 1);
  return;
}
}
void zif_call_user_method(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval ***params ;
  int n_params ;
  zval *retval_ptr ;
  zval *callback ;
  zval *object ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  zend_uint tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  params = (zval ***)((void *)0);
  n_params = 0;
  tmp = zend_parse_parameters(ht, "z/z*", & callback, & object, & params, & n_params);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if ((int )object->type != 5) {
    if ((int )object->type != 6) {
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "Second argument is not an object or class name");
      if (params) {
        _efree((void *)params);
      } else {

      }
      while (1) {
        __z = return_value;
        __z->value.lval = 0L;
        __z->type = (unsigned char)3;
        break;
      }
      return;
    } else {

    }
  } else {

  }
  if ((int )callback->type != 6) {
    _convert_to_string(callback);
  } else {

  }
  tmp___1 = call_user_function_ex(executor_globals.function_table, & object, callback, & retval_ptr, (unsigned int )n_params, params, 0, (HashTable *)((void *)0));
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
    if (retval_ptr) {
      *return_value = *retval_ptr;
      tmp___0 = zval_refcount_p(retval_ptr);
      if (tmp___0 > 1U) {
        _zval_copy_ctor(return_value);
        zval_delref_p(retval_ptr);
      } else {
        while (1) {
          if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)retval_ptr)->u.buffered & 4294967292UL)) {
            gc_remove_zval_from_buffer(retval_ptr);
          } else {

          }
          _efree((void *)retval_ptr);
          break;
        }
      }
      return_value->refcount__gc = 1U;
      return_value->is_ref__gc = (unsigned char)0;
    } else {

    }
  } else {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call %s()", callback->value.str.val);
  }
  if (n_params) {
    _efree((void *)params);
  } else {

  }
  return;
}
}
void zif_call_user_method_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *params ;
  zval ***method_args ;
  zval *retval_ptr ;
  zval *callback ;
  zval *object ;
  HashTable *params_ar ;
  int num_elems ;
  int element ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  HashTable *tmp___0 ;
  HashTable *tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  zend_uint tmp___5 ;
  int __attribute__((__visibility__("default")))  tmp___6 ;

  {
  method_args = (zval ***)((void *)0);
  element = 0;
  tmp = zend_parse_parameters(ht, "z/zA/", & callback, & object, & params);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if ((int )object->type != 5) {
    if ((int )object->type != 6) {
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "Second argument is not an object or class name");
      while (1) {
        __z = return_value;
        __z->value.lval = 0L;
        __z->type = (unsigned char)3;
        break;
      }
      return;
    } else {

    }
  } else {

  }
  if ((int )callback->type != 6) {
    _convert_to_string(callback);
  } else {

  }
  if ((int )params->type == 4) {
    params_ar = params->value.ht;
  } else {
    if ((int )params->type == 5) {
      tmp___0 = (*((params->value.obj.handlers)->get_properties))(params);
      tmp___1 = tmp___0;
    } else {
      tmp___1 = (HashTable *)((void *)0);
    }
    params_ar = tmp___1;
  }
  tmp___2 = zend_hash_num_elements((HashTable const   *)params_ar);
  num_elems = (int )tmp___2;
  tmp___3 = _safe_emalloc(sizeof(zval **), (unsigned int )num_elems, 0U);
  method_args = (zval ***)tmp___3;
  zend_hash_internal_pointer_reset_ex(params_ar, (HashPosition *)((void *)0));
  while (1) {
    tmp___4 = zend_hash_get_current_data_ex(params_ar, (void **)(method_args + element), (HashPosition *)((void *)0));
    if (tmp___4 == (int __attribute__((__visibility__("default")))  )0) {

    } else {
      break;
    }
    element ++;
    zend_hash_move_forward_ex(params_ar, (HashPosition *)((void *)0));
  }
  tmp___6 = call_user_function_ex(executor_globals.function_table, & object, callback, & retval_ptr, (unsigned int )num_elems, method_args, 0, (HashTable *)((void *)0));
  if (tmp___6 == (int __attribute__((__visibility__("default")))  )0) {
    if (retval_ptr) {
      *return_value = *retval_ptr;
      tmp___5 = zval_refcount_p(retval_ptr);
      if (tmp___5 > 1U) {
        _zval_copy_ctor(return_value);
        zval_delref_p(retval_ptr);
      } else {
        while (1) {
          if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)retval_ptr)->u.buffered & 4294967292UL)) {
            gc_remove_zval_from_buffer(retval_ptr);
          } else {

          }
          _efree((void *)retval_ptr);
          break;
        }
      }
      return_value->refcount__gc = 1U;
      return_value->is_ref__gc = (unsigned char)0;
    } else {

    }
  } else {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call %s()", callback->value.str.val);
  }
  _efree((void *)method_args);
  return;
}
}
void zif_forward_static_call(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *retval_ptr ;
  zend_fcall_info fci ;
  zend_fcall_info_cache fci_cache ;
  int __attribute__((__visibility__("default")))  tmp ;
  zend_bool __attribute__((__visibility__("default")))  tmp___0 ;
  zend_uint tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;

  {
  retval_ptr = (zval *)((void *)0);
  tmp = zend_parse_parameters(ht, "f*", & fci, & fci_cache, & fci.params, & fci.param_count);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (! (executor_globals.active_op_array)->scope) {
    zend_error(1, "Cannot call forward_static_call() when no class scope is active");
  } else {

  }
  fci.retval_ptr_ptr = & retval_ptr;
  if (executor_globals.called_scope) {
    tmp___0 = instanceof_function((zend_class_entry const   *)executor_globals.called_scope, (zend_class_entry const   *)fci_cache.calling_scope);
    if (tmp___0) {
      fci_cache.called_scope = executor_globals.called_scope;
    } else {

    }
  } else {

  }
  tmp___2 = zend_call_function(& fci, & fci_cache);
  if (tmp___2 == (int __attribute__((__visibility__("default")))  )0) {
    if (fci.retval_ptr_ptr) {
      if (*(fci.retval_ptr_ptr)) {
        *return_value = *(*(fci.retval_ptr_ptr));
        tmp___1 = zval_refcount_p(*(fci.retval_ptr_ptr));
        if (tmp___1 > 1U) {
          _zval_copy_ctor(return_value);
          zval_delref_p(*(fci.retval_ptr_ptr));
        } else {
          while (1) {
            if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)*(fci.retval_ptr_ptr))->u.buffered & 4294967292UL)) {
              gc_remove_zval_from_buffer(*(fci.retval_ptr_ptr));
            } else {

            }
            _efree((void *)*(fci.retval_ptr_ptr));
            break;
          }
        }
        return_value->refcount__gc = 1U;
        return_value->is_ref__gc = (unsigned char)0;
      } else {

      }
    } else {

    }
  } else {

  }
  if (fci.params) {
    _efree((void *)fci.params);
  } else {

  }
  return;
}
}
void zif_forward_static_call_array(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *params ;
  zval *retval_ptr ;
  zend_fcall_info fci ;
  zend_fcall_info_cache fci_cache ;
  int __attribute__((__visibility__("default")))  tmp ;
  zend_bool __attribute__((__visibility__("default")))  tmp___0 ;
  zend_uint tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;

  {
  retval_ptr = (zval *)((void *)0);
  tmp = zend_parse_parameters(ht, "fa/", & fci, & fci_cache, & params);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  zend_fcall_info_args(& fci, params);
  fci.retval_ptr_ptr = & retval_ptr;
  if (executor_globals.called_scope) {
    tmp___0 = instanceof_function((zend_class_entry const   *)executor_globals.called_scope, (zend_class_entry const   *)fci_cache.calling_scope);
    if (tmp___0) {
      fci_cache.called_scope = executor_globals.called_scope;
    } else {

    }
  } else {

  }
  tmp___2 = zend_call_function(& fci, & fci_cache);
  if (tmp___2 == (int __attribute__((__visibility__("default")))  )0) {
    if (fci.retval_ptr_ptr) {
      if (*(fci.retval_ptr_ptr)) {
        *return_value = *(*(fci.retval_ptr_ptr));
        tmp___1 = zval_refcount_p(*(fci.retval_ptr_ptr));
        if (tmp___1 > 1U) {
          _zval_copy_ctor(return_value);
          zval_delref_p(*(fci.retval_ptr_ptr));
        } else {
          while (1) {
            if ((gc_root_buffer *)((unsigned long )((zval_gc_info *)*(fci.retval_ptr_ptr))->u.buffered & 4294967292UL)) {
              gc_remove_zval_from_buffer(*(fci.retval_ptr_ptr));
            } else {

            }
            _efree((void *)*(fci.retval_ptr_ptr));
            break;
          }
        }
        return_value->refcount__gc = 1U;
        return_value->is_ref__gc = (unsigned char)0;
      } else {

      }
    } else {

    }
  } else {

  }
  zend_fcall_info_args_clear(& fci, 1);
  return;
}
}
static void user_shutdown_function_dtor(php_shutdown_function_entry *shutdown_function_entry ) 
{ int i ;

  {
  i = 0;
  while (i < shutdown_function_entry->arg_count) {
    _zval_ptr_dtor(shutdown_function_entry->arguments + i);
    i ++;
  }
  _efree((void *)shutdown_function_entry->arguments);
  return;
}
}
static void user_tick_function_dtor(user_tick_function_entry *tick_function_entry ) 
{ int i ;

  {
  i = 0;
  while (i < tick_function_entry->arg_count) {
    _zval_ptr_dtor(tick_function_entry->arguments + i);
    i ++;
  }
  _efree((void *)tick_function_entry->arguments);
  return;
}
}
static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry ) 
{ zval retval ;
  char *function_name ;
  zend_bool __attribute__((__visibility__("default")))  tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  tmp = zend_is_callable(*(shutdown_function_entry->arguments + 0), 0U, & function_name);
  if (tmp) {

  } else {
    zend_error(1 << 1L, "(Registered shutdown functions) Unable to call %s() - function does not exist", function_name);
    if (function_name) {
      _efree((void *)function_name);
    } else {

    }
    return (0);
  }
  if (function_name) {
    _efree((void *)function_name);
  } else {

  }
  tmp___0 = call_user_function(executor_globals.function_table, (zval **)((void *)0), *(shutdown_function_entry->arguments + 0), & retval, (unsigned int )(shutdown_function_entry->arg_count - 1), shutdown_function_entry->arguments + 1);
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )0) {
    _zval_dtor(& retval);
  } else {

  }
  return (0);
}
}
static void user_tick_function_call(user_tick_function_entry *tick_fe ) 
{ zval retval ;
  zval *function ;
  zval **obj ;
  zval **method ;
  zend_class_entry __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;

  {
  function = *(tick_fe->arguments + 0);
  if (! tick_fe->calling) {
    tick_fe->calling = 1;
    tmp___2 = call_user_function(executor_globals.function_table, (zval **)((void *)0), function, & retval, (unsigned int )(tick_fe->arg_count - 1), tick_fe->arguments + 1);
    if (tmp___2 == (int __attribute__((__visibility__("default")))  )0) {
      _zval_dtor(& retval);
    } else {
      if ((int )function->type == 6) {
        php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call %s() - function does not exist", function->value.str.val);
      } else {
        if ((int )function->type == 4) {
          tmp___0 = zend_hash_index_find((HashTable const   *)function->value.ht, 0UL, (void **)(& obj));
          if (tmp___0 == (int __attribute__((__visibility__("default")))  )0) {
            tmp___1 = zend_hash_index_find((HashTable const   *)function->value.ht, 1UL, (void **)(& method));
            if (tmp___1 == (int __attribute__((__visibility__("default")))  )0) {
              if ((int )(*obj)->type == 5) {
                if ((int )(*method)->type == 6) {
                  tmp = zend_get_class_entry((zval const   *)*obj);
                  php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call %s::%s() - function does not exist", tmp->name, (*method)->value.str.val);
                } else {
                  php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call tick function");
                }
              } else {
                php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call tick function");
              }
            } else {
              php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call tick function");
            }
          } else {
            php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call tick function");
          }
        } else {
          php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to call tick function");
        }
      }
    }
    tick_fe->calling = 0;
  } else {

  }
  return;
}
}
static void run_user_tick_functions(int tick_count ) 
{ 

  {
  zend_llist_apply(basic_globals.user_tick_functions, (void (*)(void * ))(& user_tick_function_call));
  return;
}
}
static int user_tick_function_compare(user_tick_function_entry *tick_fe1 , user_tick_function_entry *tick_fe2 ) 
{ zval *func1 ;
  zval *func2 ;
  int ret ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval result ;
  zval result___0 ;

  {
  func1 = *(tick_fe1->arguments + 0);
  func2 = *(tick_fe2->arguments + 0);
  if ((int )func1->type == 6) {
    if ((int )func2->type == 6) {
      tmp = zend_binary_zval_strcmp(func1, func2);
      ret = tmp == (int __attribute__((__visibility__("default")))  )0;
    } else {
      goto _L___0;
    }
  } else {
    _L___0: /* CIL Label */ 
    if ((int )func1->type == 4) {
      if ((int )func2->type == 4) {
        zend_compare_arrays(& result, func1, func2);
        ret = result.value.lval == 0L;
      } else {
        goto _L;
      }
    } else {
      _L: /* CIL Label */ 
      if ((int )func1->type == 5) {
        if ((int )func2->type == 5) {
          zend_compare_objects(& result___0, func1, func2);
          ret = result___0.value.lval == 0L;
        } else {
          ret = 0;
        }
      } else {
        ret = 0;
      }
    }
  }
  if (ret) {
    if (tick_fe1->calling) {
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to delete tick function executed at the moment");
      return (0);
    } else {

    }
  } else {

  }
  return (ret);
}
}
void php_call_shutdown_functions(void) 
{ jmp_buf *__orig_bailout ;
  jmp_buf __bailout ;
  int tmp ;

  {
  if (basic_globals.user_shutdown_function_names) {
    __orig_bailout = executor_globals.bailout;
    executor_globals.bailout = & __bailout;
    tmp = _setjmp((struct __jmp_buf_tag *)(__bailout));
    if (tmp == 0) {
      zend_hash_apply(basic_globals.user_shutdown_function_names, (int (*)(void *pDest ))(& user_shutdown_function_call));
    } else {

    }
    executor_globals.bailout = __orig_bailout;
    php_free_shutdown_functions();
  } else {

  }
  return;
}
}
void php_free_shutdown_functions(void) 
{ jmp_buf *__orig_bailout ;
  jmp_buf __bailout ;
  int tmp ;

  {
  if (basic_globals.user_shutdown_function_names) {
    __orig_bailout = executor_globals.bailout;
    executor_globals.bailout = & __bailout;
    tmp = _setjmp((struct __jmp_buf_tag *)(__bailout));
    if (tmp == 0) {
      zend_hash_destroy(basic_globals.user_shutdown_function_names);
      _efree((void *)basic_globals.user_shutdown_function_names);
      basic_globals.user_shutdown_function_names = (HashTable *)((void *)0);
    } else {

    }
    executor_globals.bailout = __orig_bailout;
  } else {

  }
  return;
}
}
void zif_register_shutdown_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ php_shutdown_function_entry shutdown_function_entry ;
  char *callback_name ;
  int i ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___2 ;

  {
  callback_name = (char *)((void *)0);
  shutdown_function_entry.arg_count = ht;
  if (shutdown_function_entry.arg_count < 1) {
    zend_wrong_param_count();
    return;
  } else {

  }
  tmp = _safe_emalloc(sizeof(zval *), (unsigned int )shutdown_function_entry.arg_count, 0U);
  shutdown_function_entry.arguments = (zval **)tmp;
  tmp___0 = _zend_get_parameters_array(ht, shutdown_function_entry.arg_count, shutdown_function_entry.arguments);
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    _efree((void *)shutdown_function_entry.arguments);
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp___2 = zend_is_callable(*(shutdown_function_entry.arguments + 0), 0U, & callback_name);
  if (tmp___2) {
    if (! basic_globals.user_shutdown_function_names) {
      tmp___1 = _emalloc(sizeof(HashTable ));
      basic_globals.user_shutdown_function_names = (HashTable *)tmp___1;
      _zend_hash_init(basic_globals.user_shutdown_function_names, 0U, (ulong (*)(char const   *arKey , uint nKeyLength ))((void *)0), (void (*)(void * ))(& user_shutdown_function_dtor), (unsigned char)0);
    } else {

    }
    i = 0;
    while (i < shutdown_function_entry.arg_count) {
      zval_addref_p(*(shutdown_function_entry.arguments + i));
      i ++;
    }
    _zend_hash_index_update_or_next_insert(basic_globals.user_shutdown_function_names, 0UL, (void *)(& shutdown_function_entry), sizeof(php_shutdown_function_entry ), (void **)((void *)0), 1 << 2);
  } else {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid shutdown callback \'%s\' passed", callback_name);
    _efree((void *)shutdown_function_entry.arguments);
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  if (callback_name) {
    _efree((void *)callback_name);
  } else {

  }
  return;
}
}
zend_bool __attribute__((__visibility__("default")))  register_user_shutdown_function(char *function_name , size_t function_len , php_shutdown_function_entry *shutdown_function_entry ) 
{ void __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  if (! basic_globals.user_shutdown_function_names) {
    tmp = _emalloc(sizeof(HashTable ));
    basic_globals.user_shutdown_function_names = (HashTable *)tmp;
    _zend_hash_init(basic_globals.user_shutdown_function_names, 0U, (ulong (*)(char const   *arKey , uint nKeyLength ))((void *)0), (void (*)(void * ))(& user_shutdown_function_dtor), (unsigned char)0);
  } else {

  }
  tmp___0 = _zend_hash_add_or_update(basic_globals.user_shutdown_function_names, (char const   *)function_name, function_len, (void *)shutdown_function_entry, sizeof(php_shutdown_function_entry ), (void **)((void *)0), 1);
  return ((unsigned char __attribute__((__visibility__("default")))  )(tmp___0 != (int __attribute__((__visibility__("default")))  )-1));
}
}
zend_bool __attribute__((__visibility__("default")))  remove_user_shutdown_function(char *function_name , size_t function_len ) 
{ int __attribute__((__visibility__("default")))  tmp ;

  {
  if (basic_globals.user_shutdown_function_names) {
    tmp = zend_hash_del_key_or_index(basic_globals.user_shutdown_function_names, (char const   *)function_name, function_len, 0UL, 0);
    return ((unsigned char __attribute__((__visibility__("default")))  )(tmp != (int __attribute__((__visibility__("default")))  )-1));
  } else {

  }
  return ((unsigned char __attribute__((__visibility__("default")))  )0);
}
}
zend_bool __attribute__((__visibility__("default")))  append_user_shutdown_function(php_shutdown_function_entry shutdown_function_entry ) 
{ void __attribute__((__visibility__("default")))  *tmp ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  if (! basic_globals.user_shutdown_function_names) {
    tmp = _emalloc(sizeof(HashTable ));
    basic_globals.user_shutdown_function_names = (HashTable *)tmp;
    _zend_hash_init(basic_globals.user_shutdown_function_names, 0U, (ulong (*)(char const   *arKey , uint nKeyLength ))((void *)0), (void (*)(void * ))(& user_shutdown_function_dtor), (unsigned char)0);
  } else {

  }
  tmp___0 = _zend_hash_index_update_or_next_insert(basic_globals.user_shutdown_function_names, 0UL, (void *)(& shutdown_function_entry), sizeof(php_shutdown_function_entry ), (void **)((void *)0), 1 << 2);
  return ((unsigned char __attribute__((__visibility__("default")))  )(tmp___0 != (int __attribute__((__visibility__("default")))  )-1));
}
}
void __attribute__((__visibility__("default")))  php_get_highlight_struct(zend_syntax_highlighter_ini *syntax_highlighter_ini___0 ) 
{ char __attribute__((__visibility__("default")))  *tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;

  {
  tmp = zend_ini_string_ex((char *)"highlight.comment", sizeof("highlight.comment"), 0, (zend_bool *)((void *)0));
  syntax_highlighter_ini___0->highlight_comment = (char *)tmp;
  tmp___0 = zend_ini_string_ex((char *)"highlight.default", sizeof("highlight.default"), 0, (zend_bool *)((void *)0));
  syntax_highlighter_ini___0->highlight_default = (char *)tmp___0;
  tmp___1 = zend_ini_string_ex((char *)"highlight.html", sizeof("highlight.html"), 0, (zend_bool *)((void *)0));
  syntax_highlighter_ini___0->highlight_html = (char *)tmp___1;
  tmp___2 = zend_ini_string_ex((char *)"highlight.keyword", sizeof("highlight.keyword"), 0, (zend_bool *)((void *)0));
  syntax_highlighter_ini___0->highlight_keyword = (char *)tmp___2;
  tmp___3 = zend_ini_string_ex((char *)"highlight.string", sizeof("highlight.string"), 0, (zend_bool *)((void *)0));
  syntax_highlighter_ini___0->highlight_string = (char *)tmp___3;
  return;
}
}
void zif_highlight_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *filename ;
  int filename_len ;
  int ret ;
  zend_syntax_highlighter_ini syntax_highlighter_ini___0 ;
  zend_bool i ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  zval *__z___1 ;
  zval *__z___2 ;

  {
  i = (zend_bool )0;
  tmp = zend_parse_parameters(ht, "p|b", & filename, & filename_len, & i);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp___0 = php_check_open_basedir((char const   *)filename);
  if (tmp___0) {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (i) {
    php_output_start_default();
  } else {

  }
  php_get_highlight_struct(& syntax_highlighter_ini___0);
  tmp___1 = highlight_file(filename, & syntax_highlighter_ini___0);
  ret = (int )tmp___1;
  if (ret == -1) {
    if (i) {
      php_output_end();
    } else {

    }
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (i) {
    php_output_get_contents(return_value);
    php_output_discard();
  } else {
    while (1) {
      __z___2 = return_value;
      __z___2->value.lval = 1L;
      __z___2->type = (unsigned char)3;
      break;
    }
    return;
  }
  return;
}
}
void zif_php_strip_whitespace(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *filename ;
  int filename_len ;
  zend_lex_state original_lex_state ;
  zend_file_handle file_handle ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  file_handle.type = (zend_stream_type )0;
  file_handle.filename = (char const   *)0;
  file_handle.opened_path = (char *)0;
  file_handle.handle.stream.handle = (void *)0;
  file_handle.handle.stream.isatty = 0;
  file_handle.handle.stream.mmap.len = 0U;
  file_handle.handle.stream.mmap.pos = 0U;
  file_handle.handle.stream.mmap.map = (void *)0;
  file_handle.handle.stream.mmap.buf = (char *)0;
  file_handle.handle.stream.mmap.old_handle = (void *)0;
  file_handle.handle.stream.mmap.old_closer = (void (*)(void *handle ))0;
  file_handle.handle.stream.reader = (size_t (*)(void *handle , char *buf , size_t len ))0;
  file_handle.handle.stream.fsizer = (size_t (*)(void *handle ))0;
  file_handle.handle.stream.closer = (void (*)(void *handle ))0;
  file_handle.free_filename = (unsigned char)0;
  tmp = zend_parse_parameters(ht, "p", & filename, & filename_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  php_output_start_default();
  file_handle.type = (enum __anonenum_zend_stream_type_43 )0;
  file_handle.filename = (char const   *)filename;
  file_handle.free_filename = (unsigned char)0;
  file_handle.opened_path = (char *)((void *)0);
  zend_save_lexical_state(& original_lex_state);
  tmp___1 = open_file_for_scanning(& file_handle);
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )-1) {
    zend_restore_lexical_state(& original_lex_state);
    php_output_end();
    while (1) {
      __z___0 = return_value;
      __z___0->value.str.len = 0;
      tmp___0 = _estrndup("", sizeof("") - 1U);
      __z___0->value.str.val = (char *)tmp___0;
      __z___0->type = (unsigned char)6;
      break;
    }
    return;
  } else {

  }
  zend_strip();
  zend_destroy_file_handle(& file_handle);
  zend_restore_lexical_state(& original_lex_state);
  php_output_get_contents(return_value);
  php_output_discard();
  return;
}
}
void zif_highlight_string(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval **expr ;
  zend_syntax_highlighter_ini syntax_highlighter_ini___0 ;
  char *hicompiled_string_description ;
  zend_bool i ;
  int old_error_reporting ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zend_uint tmp___1 ;
  zend_bool tmp___2 ;
  char __attribute__((__visibility__("default")))  *tmp___3 ;
  zval *__z___0 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  zval *__z___1 ;

  {
  i = (zend_bool )0;
  old_error_reporting = executor_globals.error_reporting;
  tmp = zend_parse_parameters(ht, "Z|b", & expr, & i);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if ((int )(*expr)->type != 6) {
    tmp___2 = zval_isref_p(*expr);
    if (tmp___2) {

    } else {
      while (1) {
        tmp___1 = zval_refcount_p(*expr);
        if (tmp___1 > 1U) {
          zval_delref_p(*expr);
          while (1) {
            tmp___0 = _emalloc(sizeof(zval_gc_info ));
            new_zv = (zval *)tmp___0;
            ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
            break;
          }
          while (1) {
            while (1) {
              new_zv->value = (*expr)->value;
              new_zv->type = (*expr)->type;
              break;
            }
            zval_set_refcount_p(new_zv, 1U);
            zval_unset_isref_p(new_zv);
            break;
          }
          *expr = new_zv;
          _zval_copy_ctor(new_zv);
        } else {

        }
        break;
      }
    }
    if ((int )(*expr)->type != 6) {
      _convert_to_string(*expr);
    } else {

    }
  } else {

  }
  if (i) {
    php_output_start_default();
  } else {

  }
  executor_globals.error_reporting = 1;
  php_get_highlight_struct(& syntax_highlighter_ini___0);
  tmp___3 = zend_make_compiled_string_description("highlighted code");
  hicompiled_string_description = (char *)tmp___3;
  tmp___4 = highlight_string(*expr, & syntax_highlighter_ini___0, hicompiled_string_description);
  if (tmp___4 == (int __attribute__((__visibility__("default")))  )-1) {
    _efree((void *)hicompiled_string_description);
    executor_globals.error_reporting = old_error_reporting;
    if (i) {
      php_output_end();
    } else {

    }
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  _efree((void *)hicompiled_string_description);
  executor_globals.error_reporting = old_error_reporting;
  if (i) {
    php_output_get_contents(return_value);
    php_output_discard();
  } else {
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 1L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  }
  return;
}
}
void zif_ini_get(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *varname ;
  char *str ;
  int varname_len ;
  int __attribute__((__visibility__("default")))  tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  tmp = zend_parse_parameters(ht, "s", & varname, & varname_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_ini_string(varname, (unsigned int )(varname_len + 1), 0);
  str = (char *)tmp___0;
  if (! str) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __s = (char const   *)str;
    __z___0 = return_value;
    tmp___1 = strlen(__s);
    __z___0->value.str.len = (int )tmp___1;
    tmp___2 = _estrndup(__s, (unsigned int )__z___0->value.str.len);
    __z___0->value.str.val = (char *)tmp___2;
    __z___0->type = (unsigned char)6;
    break;
  }
  return;
}
}
static int php_ini_get_option(zend_ini_entry *ini_entry , int num_args , va_list args , zend_hash_key *hash_key ) 
{ zval *ini_array ;
  zval *tmp ;
  int module_number ;
  int tmp___0 ;
  int details ;
  int tmp___1 ;
  zval *option ;
  void __attribute__((__visibility__("default")))  *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 ;

  {
  tmp = __builtin_va_arg(args, zval *);
  ini_array = tmp;
  tmp___0 = __builtin_va_arg(args, int );
  module_number = tmp___0;
  tmp___1 = __builtin_va_arg(args, int );
  details = tmp___1;
  if (module_number != 0) {
    if (ini_entry->module_number != module_number) {
      return (0);
    } else {

    }
  } else {

  }
  if (hash_key->nKeyLength == 0U) {
    goto _L;
  } else {
    if ((int const   )*(hash_key->arKey + 0) != 0) {
      _L: /* CIL Label */ 
      if (details) {
        while (1) {
          tmp___2 = _emalloc(sizeof(zval_gc_info ));
          option = (zval *)tmp___2;
          ((zval_gc_info *)option)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        option->refcount__gc = 1U;
        option->is_ref__gc = (unsigned char)0;
        _array_init(option, 0U);
        if (ini_entry->orig_value) {
          tmp___3 = strlen("global_value");
          add_assoc_stringl_ex(option, "global_value", tmp___3 + 1U, ini_entry->orig_value, ini_entry->orig_value_length, 1);
        } else {
          if (ini_entry->value) {
            tmp___4 = strlen("global_value");
            add_assoc_stringl_ex(option, "global_value", tmp___4 + 1U, ini_entry->value, ini_entry->value_length, 1);
          } else {
            tmp___5 = strlen("global_value");
            add_assoc_null_ex(option, "global_value", tmp___5 + 1U);
          }
        }
        if (ini_entry->value) {
          tmp___6 = strlen("local_value");
          add_assoc_stringl_ex(option, "local_value", tmp___6 + 1U, ini_entry->value, ini_entry->value_length, 1);
        } else {
          tmp___7 = strlen("local_value");
          add_assoc_null_ex(option, "local_value", tmp___7 + 1U);
        }
        tmp___8 = strlen("access");
        add_assoc_long_ex(option, "access", tmp___8 + 1U, (long )ini_entry->modifiable);
        add_assoc_zval_ex(ini_array, (char const   *)ini_entry->name, ini_entry->name_length, option);
      } else {
        if (ini_entry->value) {
          tmp___9 = strlen((char const   *)ini_entry->name);
          add_assoc_stringl_ex(ini_array, (char const   *)ini_entry->name, tmp___9 + 1U, ini_entry->value, ini_entry->value_length, 1);
        } else {
          tmp___10 = strlen((char const   *)ini_entry->name);
          add_assoc_null_ex(ini_array, (char const   *)ini_entry->name, tmp___10 + 1U);
        }
      }
    } else {

    }
  }
  return (0);
}
}
void zif_ini_get_all(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *extname ;
  int extname_len ;
  int extnumber ;
  zend_module_entry *module ;
  zend_bool details ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  extname = (char *)((void *)0);
  extname_len = 0;
  extnumber = 0;
  details = (zend_bool )1;
  tmp = zend_parse_parameters(ht, "|s!b", & extname, & extname_len, & details);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  zend_ini_sort_entries();
  if (extname) {
    tmp___0 = zend_hash_find((HashTable const   *)(& module_registry), (char const   *)extname, (unsigned int )(extname_len + 1), (void **)(& module));
    if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to find extension \'%s\'", extname);
      while (1) {
        __z = return_value;
        __z->value.lval = 0L;
        __z->type = (unsigned char)3;
        break;
      }
      return;
    } else {

    }
    extnumber = module->module_number;
  } else {

  }
  _array_init(return_value, 0U);
  zend_hash_apply_with_arguments(executor_globals.ini_directives, (int (*)(void *pDest , int num_args , va_list args , zend_hash_key *hash_key ))(& php_ini_get_option), 2, return_value, extnumber, details);
  return;
}
}
static int php_ini_check_path(char *option_name , int option_len , char *new_option_name , int new_option_len ) 
{ size_t tmp ;
  size_t tmp___0 ;
  size_t __s1_len ;
  size_t __s2_len ;
  int tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  unsigned char const   *__s2 ;
  register int __result ;
  int tmp___4 ;
  unsigned char const   *__s1 ;
  register int __result___0 ;
  int tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  size_t tmp___10 ;
  size_t tmp___11 ;
  int tmp___12 ;

  {
  if (option_len != new_option_len - 1) {
    return (0);
  } else {

  }
  if (0) {
    if (0) {
      __s1_len = strlen((char const   *)option_name);
      __s2_len = strlen((char const   *)new_option_name);
      if (! ((unsigned int )((void const   *)(option_name + 1)) - (unsigned int )((void const   *)option_name) == 1U)) {
        goto _L___0;
      } else {
        if (__s1_len >= 4U) {
          _L___0: /* CIL Label */ 
          if (! ((unsigned int )((void const   *)(new_option_name + 1)) - (unsigned int )((void const   *)new_option_name) == 1U)) {
            tmp___7 = 1;
          } else {
            if (__s2_len >= 4U) {
              tmp___7 = 1;
            } else {
              tmp___7 = 0;
            }
          }
        } else {
          tmp___7 = 0;
        }
      }
      if (tmp___7) {
        tmp___2 = __builtin_strcmp((char const   *)option_name, (char const   *)new_option_name);
        tmp___6 = tmp___2;
      } else {
        tmp___5 = __builtin_strcmp((char const   *)option_name, (char const   *)new_option_name);
        tmp___6 = tmp___5;
      }
    } else {
      tmp___5 = __builtin_strcmp((char const   *)option_name, (char const   *)new_option_name);
      tmp___6 = tmp___5;
    }
    tmp___9 = tmp___6;
  } else {
    tmp___8 = strncmp((char const   *)option_name, (char const   *)new_option_name, (unsigned int )option_len);
    tmp___9 = tmp___8;
  }
  if (tmp___9) {
    tmp___12 = 0;
  } else {
    tmp___12 = 1;
  }
  return (tmp___12);
}
}
void zif_ini_set(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *varname ;
  char *new_value ;
  int varname_len ;
  int new_value_len ;
  char *old_value ;
  int __attribute__((__visibility__("default")))  tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;
  zval *__z___0 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;
  int tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;
  int tmp___8 ;
  int tmp___9 ;
  zval *__z___2 ;
  int __attribute__((__visibility__("default")))  tmp___10 ;

  {
  tmp = zend_parse_parameters(ht, "ss", & varname, & varname_len, & new_value, & new_value_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_ini_string(varname, (unsigned int )(varname_len + 1), 0);
  old_value = (char *)tmp___0;
  if (old_value) {
    while (1) {
      __s = (char const   *)old_value;
      __z = return_value;
      tmp___1 = strlen(__s);
      __z->value.str.len = (int )tmp___1;
      tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
      __z->value.str.val = (char *)tmp___2;
      __z->type = (unsigned char)6;
      break;
    }
  } else {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  if (core_globals.open_basedir) {
    tmp___4 = php_ini_check_path(varname, varname_len, (char *)"error_log", (int )sizeof("error_log"));
    if (tmp___4) {
      goto _L;
    } else {
      tmp___5 = php_ini_check_path(varname, varname_len, (char *)"java.class.path", (int )sizeof("java.class.path"));
      if (tmp___5) {
        goto _L;
      } else {
        tmp___6 = php_ini_check_path(varname, varname_len, (char *)"java.home", (int )sizeof("java.home"));
        if (tmp___6) {
          goto _L;
        } else {
          tmp___7 = php_ini_check_path(varname, varname_len, (char *)"mail.log", (int )sizeof("mail.log"));
          if (tmp___7) {
            goto _L;
          } else {
            tmp___8 = php_ini_check_path(varname, varname_len, (char *)"java.library.path", (int )sizeof("java.library.path"));
            if (tmp___8) {
              goto _L;
            } else {
              tmp___9 = php_ini_check_path(varname, varname_len, (char *)"vpopmail.directory", (int )sizeof("vpopmail.directory"));
              if (tmp___9) {
                _L: /* CIL Label */ 
                tmp___3 = php_check_open_basedir((char const   *)new_value);
                if (tmp___3) {
                  _zval_dtor(return_value);
                  while (1) {
                    __z___1 = return_value;
                    __z___1->value.lval = 0L;
                    __z___1->type = (unsigned char)3;
                    break;
                  }
                  return;
                } else {

                }
              } else {

              }
            }
          }
        }
      }
    }
  } else {

  }
  tmp___10 = zend_alter_ini_entry_ex(varname, (unsigned int )(varname_len + 1), new_value, (unsigned int )new_value_len, 1, 1 << 4, 0);
  if (tmp___10 == (int __attribute__((__visibility__("default")))  )-1) {
    _zval_dtor(return_value);
    while (1) {
      __z___2 = return_value;
      __z___2->value.lval = 0L;
      __z___2->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  return;
}
}
void zif_ini_restore(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *varname ;
  int varname_len ;
  int __attribute__((__visibility__("default")))  tmp ;

  {
  tmp = zend_parse_parameters(ht, "s", & varname, & varname_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  zend_restore_ini_entry(varname, (unsigned int )(varname_len + 1), 1 << 4);
  return;
}
}
void zif_set_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *new_value ;
  int new_value_len ;
  char *old_value ;
  int __attribute__((__visibility__("default")))  tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  char const   *__s ;
  zval *__z ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;
  zval *__z___0 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___3 ;

  {
  tmp = zend_parse_parameters(ht, "s", & new_value, & new_value_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_ini_string((char *)"include_path", sizeof("include_path"), 0);
  old_value = (char *)tmp___0;
  if (old_value) {
    while (1) {
      __s = (char const   *)old_value;
      __z = return_value;
      tmp___1 = strlen(__s);
      __z->value.str.len = (int )tmp___1;
      tmp___2 = _estrndup(__s, (unsigned int )__z->value.str.len);
      __z->value.str.val = (char *)tmp___2;
      __z->type = (unsigned char)6;
      break;
    }
  } else {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
  }
  tmp___3 = zend_alter_ini_entry_ex((char *)"include_path", sizeof("include_path"), new_value, (unsigned int )new_value_len, 1, 1 << 4, 0);
  if (tmp___3 == (int __attribute__((__visibility__("default")))  )-1) {
    _zval_dtor(return_value);
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  return;
}
}
void zif_get_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *str ;
  int __attribute__((__visibility__("default")))  tmp ;
  char __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___1 ;
  char __attribute__((__visibility__("default")))  *tmp___2 ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_ini_string((char *)"include_path", sizeof("include_path"), 0);
  str = (char *)tmp___0;
  if ((unsigned int )str == (unsigned int )((void *)0)) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __s = (char const   *)str;
    __z___0 = return_value;
    tmp___1 = strlen(__s);
    __z___0->value.str.len = (int )tmp___1;
    tmp___2 = _estrndup(__s, (unsigned int )__z___0->value.str.len);
    __z___0->value.str.val = (char *)tmp___2;
    __z___0->type = (unsigned char)6;
    break;
  }
  return;
}
}
void zif_restore_include_path(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ int __attribute__((__visibility__("default")))  tmp ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  zend_restore_ini_entry((char *)"include_path", sizeof("include_path"), 1 << 4);
  return;
}
}
void zif_print_r(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *var ;
  zend_bool do_return ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;

  {
  do_return = (zend_bool )0;
  tmp = zend_parse_parameters(ht, "z|b", & var, & do_return);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (do_return) {
    php_output_start_default();
  } else {

  }
  zend_print_zval_r(var, 0);
  if (do_return) {
    php_output_get_contents(return_value);
    php_output_discard();
  } else {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 1L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  }
  return;
}
}
void zif_connection_aborted(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *__z ;

  {
  __z = return_value;
  __z->value.lval = (long )((int )core_globals.connection_status & 1);
  __z->type = (unsigned char)1;
  return;
}
}
void zif_connection_status(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *__z ;

  {
  __z = return_value;
  __z->value.lval = (long )core_globals.connection_status;
  __z->type = (unsigned char)1;
  return;
}
}
void zif_ignore_user_abort(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *arg ;
  int arg_len ;
  int old_setting ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;

  {
  arg = (char *)((void *)0);
  arg_len = 0;
  tmp = zend_parse_parameters(ht, "|s", & arg, & arg_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  old_setting = (int )core_globals.ignore_user_abort;
  if (arg) {
    zend_alter_ini_entry_ex((char *)"ignore_user_abort", sizeof("ignore_user_abort"), arg, (unsigned int )arg_len, 1, 1 << 4, 0);
  } else {

  }
  __z = return_value;
  __z->value.lval = (long )old_setting;
  __z->type = (unsigned char)1;
  return;
}
}
void zif_getservbyname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *name ;
  char *proto ;
  int name_len ;
  int proto_len ;
  struct servent *serv ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  zval *__z___0 ;
  register unsigned short __v ;
  register unsigned short __x ;

  {
  tmp = zend_parse_parameters(ht, "ss", & name, & name_len, & proto, & proto_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  serv = getservbyname((char const   *)name, (char const   *)proto);
  if ((unsigned int )serv == (unsigned int )((void *)0)) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  __z___0 = return_value;
  __x = (unsigned short )serv->s_port;
  __asm__  ("rorw $8, %w0": "=r" (__v): "0" (__x): "cc");
  __z___0->value.lval = (long )__v;
  __z___0->type = (unsigned char)1;
  return;
}
}
void zif_getservbyport(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *proto ;
  int proto_len ;
  long port ;
  struct servent *serv ;
  int __attribute__((__visibility__("default")))  tmp ;
  register unsigned short __v ;
  register unsigned short __x ;
  zval *__z ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  tmp = zend_parse_parameters(ht, "ls", & port, & proto, & proto_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  __x = (unsigned short )port;
  __asm__  ("rorw $8, %w0": "=r" (__v): "0" (__x): "cc");
  serv = getservbyport((int )__v, (char const   *)proto);
  if ((unsigned int )serv == (unsigned int )((void *)0)) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __s = (char const   *)serv->s_name;
    __z___0 = return_value;
    tmp___0 = strlen(__s);
    __z___0->value.str.len = (int )tmp___0;
    tmp___1 = _estrndup(__s, (unsigned int )__z___0->value.str.len);
    __z___0->value.str.val = (char *)tmp___1;
    __z___0->type = (unsigned char)6;
    break;
  }
  return;
}
}
void zif_getprotobyname(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *name ;
  int name_len ;
  struct protoent *ent ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  zval *__z___0 ;

  {
  tmp = zend_parse_parameters(ht, "s", & name, & name_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  ent = getprotobyname((char const   *)name);
  if ((unsigned int )ent == (unsigned int )((void *)0)) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  __z___0 = return_value;
  __z___0->value.lval = (long )ent->p_proto;
  __z___0->type = (unsigned char)1;
  return;
}
}
void zif_getprotobynumber(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ long proto ;
  struct protoent *ent ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  char const   *__s ;
  zval *__z___0 ;
  size_t tmp___0 ;
  char __attribute__((__visibility__("default")))  *tmp___1 ;

  {
  tmp = zend_parse_parameters(ht, "l", & proto);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  ent = getprotobynumber((int )proto);
  if ((unsigned int )ent == (unsigned int )((void *)0)) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  while (1) {
    __s = (char const   *)ent->p_name;
    __z___0 = return_value;
    tmp___0 = strlen(__s);
    __z___0->value.str.len = (int )tmp___0;
    tmp___1 = _estrndup(__s, (unsigned int )__z___0->value.str.len);
    __z___0->value.str.val = (char *)tmp___1;
    __z___0->type = (unsigned char)6;
    break;
  }
  return;
}
}
void zif_register_tick_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ user_tick_function_entry tick_fe ;
  int i ;
  char *function_name ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval *__z___0 ;
  zend_bool __attribute__((__visibility__("default")))  tmp___1 ;
  zval *new_zv ;
  void __attribute__((__visibility__("default")))  *tmp___2 ;
  zend_uint tmp___3 ;
  zend_bool tmp___4 ;
  void __attribute__((__visibility__("default")))  *tmp___5 ;
  zval *__z___1 ;

  {
  function_name = (char *)((void *)0);
  tick_fe.calling = 0;
  tick_fe.arg_count = ht;
  if (tick_fe.arg_count < 1) {
    zend_wrong_param_count();
    return;
  } else {

  }
  tmp = _safe_emalloc(sizeof(zval *), (unsigned int )tick_fe.arg_count, 0U);
  tick_fe.arguments = (zval **)tmp;
  tmp___0 = _zend_get_parameters_array(ht, tick_fe.arg_count, tick_fe.arguments);
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    _efree((void *)tick_fe.arguments);
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp___1 = zend_is_callable(*(tick_fe.arguments + 0), 0U, & function_name);
  if (tmp___1) {
    if (function_name) {
      _efree((void *)function_name);
    } else {

    }
  } else {
    _efree((void *)tick_fe.arguments);
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Invalid tick callback \'%s\' passed", function_name);
    _efree((void *)function_name);
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  }
  if ((int )(*(tick_fe.arguments + 0))->type != 4) {
    if ((int )(*(tick_fe.arguments + 0))->type != 5) {
      if ((int )(*(tick_fe.arguments + 0))->type != 6) {
        tmp___4 = zval_isref_p(*(tick_fe.arguments + 0));
        if (tmp___4) {

        } else {
          while (1) {
            tmp___3 = zval_refcount_p(*(tick_fe.arguments + 0));
            if (tmp___3 > 1U) {
              zval_delref_p(*(tick_fe.arguments + 0));
              while (1) {
                tmp___2 = _emalloc(sizeof(zval_gc_info ));
                new_zv = (zval *)tmp___2;
                ((zval_gc_info *)new_zv)->u.buffered = (gc_root_buffer *)((void *)0);
                break;
              }
              while (1) {
                while (1) {
                  new_zv->value = (*(tick_fe.arguments + 0))->value;
                  new_zv->type = (*(tick_fe.arguments + 0))->type;
                  break;
                }
                zval_set_refcount_p(new_zv, 1U);
                zval_unset_isref_p(new_zv);
                break;
              }
              *(tick_fe.arguments + 0) = new_zv;
              _zval_copy_ctor(new_zv);
            } else {

            }
            break;
          }
        }
        if ((int )(*(tick_fe.arguments + 0))->type != 6) {
          _convert_to_string(*(tick_fe.arguments + 0));
        } else {

        }
      } else {

      }
    } else {

    }
  } else {

  }
  if (! basic_globals.user_tick_functions) {
    tmp___5 = _emalloc(sizeof(zend_llist ));
    basic_globals.user_tick_functions = (zend_llist *)tmp___5;
    zend_llist_init(basic_globals.user_tick_functions, sizeof(user_tick_function_entry ), (void (*)(void * ))(& user_tick_function_dtor), (unsigned char)0);
    php_add_tick_function(& run_user_tick_functions);
  } else {

  }
  i = 0;
  while (i < tick_fe.arg_count) {
    zval_addref_p(*(tick_fe.arguments + i));
    i ++;
  }
  zend_llist_add_element(basic_globals.user_tick_functions, (void *)(& tick_fe));
  while (1) {
    __z___1 = return_value;
    __z___1->value.lval = 1L;
    __z___1->type = (unsigned char)3;
    break;
  }
  return;
}
}
void zif_unregister_tick_function(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ zval *function ;
  user_tick_function_entry tick_fe ;
  int __attribute__((__visibility__("default")))  tmp ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;

  {
  tmp = zend_parse_parameters(ht, "z/", & function);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  if (! basic_globals.user_tick_functions) {
    return;
  } else {

  }
  if ((int )function->type != 4) {
    if ((int )function->type != 6) {
      _convert_to_string(function);
    } else {

    }
  } else {

  }
  tmp___0 = _emalloc(sizeof(zval *));
  tick_fe.arguments = (zval **)tmp___0;
  *(tick_fe.arguments + 0) = function;
  tick_fe.arg_count = 1;
  zend_llist_del_element(basic_globals.user_tick_functions, (void *)(& tick_fe), (int (*)(void * , void * ))(& user_tick_function_compare));
  _efree((void *)tick_fe.arguments);
  return;
}
}
void zif_is_uploaded_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *path ;
  int path_len ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  if (! sapi_globals.rfc1867_uploaded_files) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp = zend_parse_parameters(ht, "s", & path, & path_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_hash_exists((HashTable const   *)sapi_globals.rfc1867_uploaded_files, (char const   *)path, (unsigned int )(path_len + 1));
  if (tmp___0) {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 1L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  } else {
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  }
}
}
void zif_move_uploaded_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *path ;
  char *new_path ;
  int path_len ;
  int new_path_len ;
  zend_bool successful ;
  int oldmask ;
  int ret ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  int __attribute__((__visibility__("default")))  tmp___0 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;
  __mode_t tmp___2 ;
  int *tmp___3 ;
  char *tmp___4 ;
  int __attribute__((__visibility__("default")))  tmp___5 ;
  int tmp___6 ;
  zval *__z___2 ;

  {
  successful = (zend_bool )0;
  if (! sapi_globals.rfc1867_uploaded_files) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp = zend_parse_parameters(ht, "ss", & path, & path_len, & new_path, & new_path_len);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = zend_hash_exists((HashTable const   *)sapi_globals.rfc1867_uploaded_files, (char const   *)path, (unsigned int )(path_len + 1));
  if (tmp___0) {

  } else {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  }
  tmp___1 = php_check_open_basedir((char const   *)new_path);
  if (tmp___1) {
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  tmp___6 = rename((char const   *)path, (char const   *)new_path);
  if (tmp___6 == 0) {
    successful = (unsigned char)1;
    tmp___2 = umask(63U);
    oldmask = (int )tmp___2;
    umask((unsigned int )oldmask);
    ret = chmod((char const   *)new_path, (unsigned int )(0666 & ~ oldmask));
    if (ret == -1) {
      tmp___3 = __errno_location();
      tmp___4 = strerror(*tmp___3);
      php_error_docref0((char const   *)((void *)0), 1 << 1L, "%s", tmp___4);
    } else {

    }
  } else {
    tmp___5 = php_copy_file_ex(path, new_path, 0x00000400);
    if (tmp___5 == (int __attribute__((__visibility__("default")))  )0) {
      unlink((char const   *)path);
      successful = (unsigned char)1;
    } else {

    }
  }
  if (successful) {
    zend_hash_del_key_or_index(sapi_globals.rfc1867_uploaded_files, (char const   *)path, (unsigned int )(path_len + 1), 0UL, 0);
  } else {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Unable to move \'%s\' to \'%s\'", path, new_path);
  }
  while (1) {
    __z___2 = return_value;
    __z___2->value.lval = (long )((int )successful != 0);
    __z___2->type = (unsigned char)3;
    break;
  }
  return;
}
}
static void php_simple_ini_parser_cb(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , zval *arr ) 
{ zval *element ;
  void __attribute__((__visibility__("default")))  *tmp ;
  zval *hash ;
  zval **find_hash ;
  ulong key ;
  long __attribute__((__visibility__("default")))  tmp___0 ;
  void __attribute__((__visibility__("default")))  *tmp___1 ;
  int __attribute__((__visibility__("default")))  tmp___2 ;
  void __attribute__((__visibility__("default")))  *tmp___3 ;
  int __attribute__((__visibility__("default")))  tmp___4 ;
  zend_uchar tmp___5 ;
  void __attribute__((__visibility__("default")))  *tmp___6 ;

  {
  switch (callback_type) {
  case 1: 
  if (! arg2) {
    break;
  } else {

  }
  while (1) {
    tmp = _emalloc(sizeof(zval_gc_info ));
    element = (zval *)tmp;
    ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  while (1) {
    while (1) {
      element->value = arg2->value;
      element->type = arg2->type;
      break;
    }
    zval_set_refcount_p(element, 1U);
    zval_unset_isref_p(element);
    break;
  }
  _zval_copy_ctor(element);
  zend_symtable_update(arr->value.ht, (char const   *)arg1->value.str.val, (unsigned int )(arg1->value.str.len + 1), (void *)(& element), sizeof(zval *), (void **)((void *)0));
  break;
  case 3: 
  if (! arg2) {
    break;
  } else {

  }
  if (arg1->value.str.len > 1) {
    if ((int )*(arg1->value.str.val + 0) == 48) {
      _L: /* CIL Label */ 
      tmp___4 = zend_hash_find((HashTable const   *)arr->value.ht, (char const   *)arg1->value.str.val, (unsigned int )(arg1->value.str.len + 1), (void **)(& find_hash));
      if (tmp___4 == (int __attribute__((__visibility__("default")))  )-1) {
        while (1) {
          tmp___3 = _emalloc(sizeof(zval_gc_info ));
          hash = (zval *)tmp___3;
          ((zval_gc_info *)hash)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        hash->refcount__gc = 1U;
        hash->is_ref__gc = (unsigned char)0;
        _array_init(hash, 0U);
        _zend_hash_add_or_update(arr->value.ht, (char const   *)arg1->value.str.val, (unsigned int )(arg1->value.str.len + 1), (void *)(& hash), sizeof(zval *), (void **)((void *)0), 1);
      } else {
        hash = *find_hash;
      }
    } else {
      goto _L___0;
    }
  } else {
    _L___0: /* CIL Label */ 
    tmp___5 = is_numeric_string((char const   *)arg1->value.str.val, arg1->value.str.len, (long *)((void *)0), (double *)((void *)0), 0);
    if ((int )tmp___5 == 1) {
      tmp___0 = zend_atol((char const   *)arg1->value.str.val, arg1->value.str.len);
      key = (unsigned long )tmp___0;
      tmp___2 = zend_hash_index_find((HashTable const   *)arr->value.ht, key, (void **)(& find_hash));
      if (tmp___2 == (int __attribute__((__visibility__("default")))  )-1) {
        while (1) {
          tmp___1 = _emalloc(sizeof(zval_gc_info ));
          hash = (zval *)tmp___1;
          ((zval_gc_info *)hash)->u.buffered = (gc_root_buffer *)((void *)0);
          break;
        }
        hash->refcount__gc = 1U;
        hash->is_ref__gc = (unsigned char)0;
        _array_init(hash, 0U);
        _zend_hash_index_update_or_next_insert(arr->value.ht, key, (void *)(& hash), sizeof(zval *), (void **)((void *)0), 1);
      } else {
        hash = *find_hash;
      }
    } else {
      goto _L;
    }
  }
  if ((int )hash->type != 4) {
    _zval_dtor(hash);
    hash->refcount__gc = 1U;
    hash->is_ref__gc = (unsigned char)0;
    _array_init(hash, 0U);
  } else {

  }
  while (1) {
    tmp___6 = _emalloc(sizeof(zval_gc_info ));
    element = (zval *)tmp___6;
    ((zval_gc_info *)element)->u.buffered = (gc_root_buffer *)((void *)0);
    break;
  }
  while (1) {
    while (1) {
      element->value = arg2->value;
      element->type = arg2->type;
      break;
    }
    zval_set_refcount_p(element, 1U);
    zval_unset_isref_p(element);
    break;
  }
  _zval_copy_ctor(element);
  if (arg3) {
    if (arg3->value.str.len > 0) {
      add_assoc_zval_ex(hash, (char const   *)arg3->value.str.val, (unsigned int )(arg3->value.str.len + 1), element);
    } else {
      add_next_index_zval(hash, element);
    }
  } else {
    add_next_index_zval(hash, element);
  }
  break;
  case 2: 
  break;
  }
  return;
}
}
static void php_ini_parser_cb_with_sections(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , zval *arr ) 
{ void __attribute__((__visibility__("default")))  *tmp ;
  zval *active_arr ;

  {
  if (callback_type == 2) {
    while (1) {
      tmp = _emalloc(sizeof(zval_gc_info ));
      basic_globals.active_ini_file_section = (zval *)tmp;
      ((zval_gc_info *)basic_globals.active_ini_file_section)->u.buffered = (gc_root_buffer *)((void *)0);
      break;
    }
    (basic_globals.active_ini_file_section)->refcount__gc = 1U;
    (basic_globals.active_ini_file_section)->is_ref__gc = (unsigned char)0;
    _array_init(basic_globals.active_ini_file_section, 0U);
    zend_symtable_update(arr->value.ht, (char const   *)arg1->value.str.val, (unsigned int )(arg1->value.str.len + 1), (void *)(& basic_globals.active_ini_file_section), sizeof(zval *), (void **)((void *)0));
  } else {
    if (arg2) {
      if (basic_globals.active_ini_file_section) {
        active_arr = basic_globals.active_ini_file_section;
      } else {
        active_arr = arr;
      }
      php_simple_ini_parser_cb(arg1, arg2, arg3, callback_type, active_arr);
    } else {

    }
  }
  return;
}
}
void zif_parse_ini_file(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *filename ;
  int filename_len ;
  zend_bool process_sections ;
  long scanner_mode ;
  zend_file_handle fh ;
  void (*ini_parser_cb)(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , void *arg ) ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___0 ;

  {
  filename = (char *)((void *)0);
  filename_len = 0;
  process_sections = (zend_bool )0;
  scanner_mode = 0L;
  tmp = zend_parse_parameters(ht, "p|bl", & filename, & filename_len, & process_sections, & scanner_mode);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (filename_len == 0) {
    php_error_docref0((char const   *)((void *)0), 1 << 1L, "Filename cannot be empty!");
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (process_sections) {
    basic_globals.active_ini_file_section = (zval *)((void *)0);
    ini_parser_cb = (void (*)(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , void *arg ))(& php_ini_parser_cb_with_sections);
  } else {
    ini_parser_cb = (void (*)(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , void *arg ))(& php_simple_ini_parser_cb);
  }
  memset((void *)(& fh), 0, sizeof(fh));
  fh.filename = (char const   *)filename;
  fh.type = (enum __anonenum_zend_stream_type_43 )0;
  _array_init(return_value, 0U);
  tmp___0 = zend_parse_ini_file(& fh, (unsigned char)0, (int )scanner_mode, ini_parser_cb, (void *)return_value);
  if (tmp___0 == (int __attribute__((__visibility__("default")))  )-1) {
    zend_hash_destroy(return_value->value.ht);
    _efree((void *)return_value->value.ht);
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  return;
}
}
void zif_parse_ini_string(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ char *string ;
  char *str ;
  int str_len ;
  zend_bool process_sections ;
  long scanner_mode ;
  void (*ini_parser_cb)(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , void *arg ) ;
  zval *__z ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z___0 ;
  void __attribute__((__visibility__("default")))  *tmp___0 ;
  zval *__z___1 ;
  int __attribute__((__visibility__("default")))  tmp___1 ;

  {
  string = (char *)((void *)0);
  str = (char *)((void *)0);
  str_len = 0;
  process_sections = (zend_bool )0;
  scanner_mode = 0L;
  tmp = zend_parse_parameters(ht, "s|bl", & str, & str_len, & process_sections, & scanner_mode);
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {

  }
  if (2147483647 - str_len < 32) {
    while (1) {
      __z___0 = return_value;
      __z___0->value.lval = 0L;
      __z___0->type = (unsigned char)3;
      break;
    }
  } else {

  }
  if (process_sections) {
    basic_globals.active_ini_file_section = (zval *)((void *)0);
    ini_parser_cb = (void (*)(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , void *arg ))(& php_ini_parser_cb_with_sections);
  } else {
    ini_parser_cb = (void (*)(zval *arg1 , zval *arg2 , zval *arg3 , int callback_type , void *arg ))(& php_simple_ini_parser_cb);
  }
  tmp___0 = _emalloc((unsigned int )(str_len + 32));
  string = (char *)tmp___0;
  memcpy((void */* __restrict  */)string, (void const   */* __restrict  */)str, (unsigned int )str_len);
  memset((void *)(string + str_len), 0, 32U);
  _array_init(return_value, 0U);
  tmp___1 = zend_parse_ini_string(string, (unsigned char)0, (int )scanner_mode, ini_parser_cb, (void *)return_value);
  if (tmp___1 == (int __attribute__((__visibility__("default")))  )-1) {
    zend_hash_destroy(return_value->value.ht);
    _efree((void *)return_value->value.ht);
    while (1) {
      __z___1 = return_value;
      __z___1->value.lval = 0L;
      __z___1->type = (unsigned char)3;
      break;
    }
  } else {

  }
  _efree((void *)string);
  return;
}
}
void zif_sys_getloadavg(int ht , zval *return_value , zval **return_value_ptr , zval *this_ptr , int return_value_used ) 
{ double load[3] ;
  int __attribute__((__visibility__("default")))  tmp ;
  zval *__z ;
  int tmp___0 ;

  {
  tmp = zend_parse_parameters(ht, "");
  if (tmp == (int __attribute__((__visibility__("default")))  )-1) {
    return;
  } else {

  }
  tmp___0 = getloadavg(load, 3);
  if (tmp___0 == -1) {
    while (1) {
      __z = return_value;
      __z->value.lval = 0L;
      __z->type = (unsigned char)3;
      break;
    }
    return;
  } else {
    _array_init(return_value, 0U);
    add_index_double(return_value, 0UL, load[0]);
    add_index_double(return_value, 1UL, load[1]);
    add_index_double(return_value, 2UL, load[2]);
  }
  return;
}
}
