struct _IO_FILE;
struct _IO_FILE *_coverage_fout  ;
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_1 {
   int __val[2] ;
};
typedef struct __anonstruct___fsid_t_1 __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 __ino64_t ino_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 __off64_t off_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 unsigned int size_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_2 {
   unsigned long __val[1024U / (8U * sizeof(unsigned long ))] ;
};
typedef struct __anonstruct___sigset_t_2 __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 __suseconds_t suseconds_t;
typedef long __fd_mask;
struct __anonstruct_fd_set_3 {
   __fd_mask __fds_bits[1024 / (8 * (int )sizeof(__fd_mask ))] ;
};
typedef struct __anonstruct_fd_set_3 fd_set;
typedef __fd_mask fd_mask;
typedef __blksize_t blksize_t;
typedef __blkcnt64_t blkcnt_t;
typedef __fsblkcnt64_t fsblkcnt_t;
typedef __fsfilcnt64_t fsfilcnt_t;
typedef unsigned long pthread_t;
union __anonunion_pthread_attr_t_4 {
   char __size[36] ;
   long __align ;
};
typedef union __anonunion_pthread_attr_t_4 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_6 {
   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_6 __annonCompField1 ;
};
union __anonunion_pthread_mutex_t_5 {
   struct __pthread_mutex_s __data ;
   char __size[24] ;
   long __align ;
};
typedef union __anonunion_pthread_mutex_t_5 pthread_mutex_t;
union __anonunion_pthread_mutexattr_t_7 {
   char __size[4] ;
   long __align ;
};
typedef union __anonunion_pthread_mutexattr_t_7 pthread_mutexattr_t;
struct __anonstruct___data_9 {
   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_8 {
   struct __anonstruct___data_9 __data ;
   char __size[48] ;
   long long __align ;
};
typedef union __anonunion_pthread_cond_t_8 pthread_cond_t;
union __anonunion_pthread_condattr_t_10 {
   char __size[4] ;
   long __align ;
};
typedef union __anonunion_pthread_condattr_t_10 pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
struct __anonstruct___data_12 {
   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_11 {
   struct __anonstruct___data_12 __data ;
   char __size[32] ;
   long __align ;
};
typedef union __anonunion_pthread_rwlock_t_11 pthread_rwlock_t;
union __anonunion_pthread_rwlockattr_t_13 {
   char __size[8] ;
   long __align ;
};
typedef union __anonunion_pthread_rwlockattr_t_13 pthread_rwlockattr_t;
typedef int volatile   pthread_spinlock_t;
union __anonunion_pthread_barrier_t_14 {
   char __size[20] ;
   long __align ;
};
typedef union __anonunion_pthread_barrier_t_14 pthread_barrier_t;
union __anonunion_pthread_barrierattr_t_15 {
   char __size[4] ;
   int __align ;
};
typedef union __anonunion_pthread_barrierattr_t_15 pthread_barrierattr_t;
struct flock {
   short l_type ;
   short l_whence ;
   __off64_t l_start ;
   __off64_t l_len ;
   __pid_t l_pid ;
};
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 ;
   __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 __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 int (*__compar_fn_t)(void const   * , void const   * );
enum __anonenum_ACTION_16 {
    FIND = 0,
    ENTER = 1
} ;
typedef enum __anonenum_ACTION_16 ACTION;
struct entry {
   char *key ;
   void *data ;
};
typedef struct entry ENTRY;
struct _ENTRY;
enum __anonenum_VISIT_17 {
    preorder = 0,
    postorder = 1,
    endorder = 2,
    leaf = 3
} ;
typedef enum __anonenum_VISIT_17 VISIT;
typedef void (*__action_fn_t)(void const   *__nodep , VISIT __value ,
                              int __level );
typedef signed char int8;
typedef unsigned char uint8;
typedef short int16;
typedef unsigned short uint16;
typedef int int32;
typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef int uint16_vap;
struct __anonstruct_TIFFHeaderCommon_18 {
   uint16 tiff_magic ;
   uint16 tiff_version ;
};
typedef struct __anonstruct_TIFFHeaderCommon_18 TIFFHeaderCommon;
struct __anonstruct_TIFFHeaderClassic_19 {
   uint16 tiff_magic ;
   uint16 tiff_version ;
   uint32 tiff_diroff ;
};
typedef struct __anonstruct_TIFFHeaderClassic_19 TIFFHeaderClassic;
struct __anonstruct_TIFFHeaderBig_20 {
   uint16 tiff_magic ;
   uint16 tiff_version ;
   uint16 tiff_offsetsize ;
   uint16 tiff_unused ;
   uint64 tiff_diroff ;
};
typedef struct __anonstruct_TIFFHeaderBig_20 TIFFHeaderBig;
enum __anonenum_TIFFDataType_21 {
    TIFF_NOTYPE = 0,
    TIFF_BYTE = 1,
    TIFF_ASCII = 2,
    TIFF_SHORT = 3,
    TIFF_LONG = 4,
    TIFF_RATIONAL = 5,
    TIFF_SBYTE = 6,
    TIFF_UNDEFINED = 7,
    TIFF_SSHORT = 8,
    TIFF_SLONG = 9,
    TIFF_SRATIONAL = 10,
    TIFF_FLOAT = 11,
    TIFF_DOUBLE = 12,
    TIFF_IFD = 13,
    TIFF_LONG8 = 16,
    TIFF_SLONG8 = 17,
    TIFF_IFD8 = 18
} ;
typedef enum __anonenum_TIFFDataType_21 TIFFDataType;
enum __anonenum_TIFFSetGetFieldType_22 {
    TIFF_SETGET_UNDEFINED = 0,
    TIFF_SETGET_ASCII = 1,
    TIFF_SETGET_UINT8 = 2,
    TIFF_SETGET_UINT16 = 3,
    TIFF_SETGET_UINT32 = 4,
    TIFF_SETGET_UINT64 = 5,
    TIFF_SETGET_DOUBLE = 6,
    TIFF_SETGET_IFD8 = 7,
    TIFF_SETGET_INT = 8,
    TIFF_SETGET_UINT16_PAIR = 9,
    TIFF_SETGET_C0_UINT8 = 10,
    TIFF_SETGET_C0_UINT16 = 11,
    TIFF_SETGET_C0_UINT32 = 12,
    TIFF_SETGET_C0_FLOAT = 13,
    TIFF_SETGET_C16_ASCII = 14,
    TIFF_SETGET_C16_UINT8 = 15,
    TIFF_SETGET_C16_UINT16 = 16,
    TIFF_SETGET_C16_UINT32 = 17,
    TIFF_SETGET_C16_UINT64 = 18,
    TIFF_SETGET_C16_FLOAT = 19,
    TIFF_SETGET_C16_IFD8 = 20,
    TIFF_SETGET_C32_ASCII = 21,
    TIFF_SETGET_C32_UINT8 = 22,
    TIFF_SETGET_C32_SINT8 = 23,
    TIFF_SETGET_C32_UINT16 = 24,
    TIFF_SETGET_C32_SINT16 = 25,
    TIFF_SETGET_C32_UINT32 = 26,
    TIFF_SETGET_C32_SINT32 = 27,
    TIFF_SETGET_C32_UINT64 = 28,
    TIFF_SETGET_C32_SINT64 = 29,
    TIFF_SETGET_C32_FLOAT = 30,
    TIFF_SETGET_C32_DOUBLE = 31,
    TIFF_SETGET_C32_IFD8 = 32,
    TIFF_SETGET_OTHER = 33
} ;
typedef enum __anonenum_TIFFSetGetFieldType_22 TIFFSetGetFieldType;
struct tiff;
typedef struct tiff TIFF;
typedef long tmsize_t;
typedef uint32 ttag_t;
typedef uint16 tdir_t;
typedef uint16 tsample_t;
typedef uint32 tstrile_t;
typedef tstrile_t tstrip_t;
typedef tstrile_t ttile_t;
typedef tmsize_t tsize_t;
typedef void *tdata_t;
typedef uint64 toff_t;
typedef void *thandle_t;
typedef unsigned char TIFFRGBValue;
struct __anonstruct_TIFFDisplay_23 {
   float d_mat[3][3] ;
   float d_YCR ;
   float d_YCG ;
   float d_YCB ;
   uint32 d_Vrwr ;
   uint32 d_Vrwg ;
   uint32 d_Vrwb ;
   float d_Y0R ;
   float d_Y0G ;
   float d_Y0B ;
   float d_gammaR ;
   float d_gammaG ;
   float d_gammaB ;
};
typedef struct __anonstruct_TIFFDisplay_23 TIFFDisplay;
struct __anonstruct_TIFFYCbCrToRGB_24 {
   TIFFRGBValue *clamptab ;
   int *Cr_r_tab ;
   int *Cb_b_tab ;
   int32 *Cr_g_tab ;
   int32 *Cb_g_tab ;
   int32 *Y_tab ;
};
typedef struct __anonstruct_TIFFYCbCrToRGB_24 TIFFYCbCrToRGB;
struct __anonstruct_TIFFCIELabToRGB_25 {
   int range ;
   float rstep ;
   float gstep ;
   float bstep ;
   float X0 ;
   float Y0 ;
   float Z0 ;
   TIFFDisplay display ;
   float Yr2r[1501] ;
   float Yg2g[1501] ;
   float Yb2b[1501] ;
};
typedef struct __anonstruct_TIFFCIELabToRGB_25 TIFFCIELabToRGB;
struct _TIFFRGBAImage;
typedef struct _TIFFRGBAImage TIFFRGBAImage;
typedef void (*tileContigRoutine)(TIFFRGBAImage * , uint32 * , uint32  ,
                                  uint32  , uint32  , uint32  , int32  ,
                                  int32  , unsigned char * );
typedef void (*tileSeparateRoutine)(TIFFRGBAImage * , uint32 * , uint32  ,
                                    uint32  , uint32  , uint32  , int32  ,
                                    int32  , unsigned char * , unsigned char * ,
                                    unsigned char * , unsigned char * );
union __anonunion_put_26 {
   void (*any)(TIFFRGBAImage * ) ;
   void (*contig)(TIFFRGBAImage * , uint32 * , uint32  , uint32  , uint32  ,
                  uint32  , int32  , int32  , unsigned char * ) ;
   void (*separate)(TIFFRGBAImage * , uint32 * , uint32  , uint32  , uint32  ,
                    uint32  , int32  , int32  , unsigned char * ,
                    unsigned char * , unsigned char * , unsigned char * ) ;
};
struct _TIFFRGBAImage {
   TIFF *tif ;
   int stoponerr ;
   int isContig ;
   int alpha ;
   uint32 width ;
   uint32 height ;
   uint16 SubsamplingHor ;
   uint16 SubsamplingVer ;
   uint16 bitspersample ;
   uint16 samplesperpixel ;
   uint16 orientation ;
   uint16 req_orientation ;
   uint16 photometric ;
   uint16 *redcmap ;
   uint16 *greencmap ;
   uint16 *bluecmap ;
   int (*get)(TIFFRGBAImage * , uint32 * , uint32  , uint32  ) ;
   union __anonunion_put_26 put ;
   TIFFRGBValue *Map ;
   uint32 **BWmap ;
   uint32 **PALmap ;
   TIFFYCbCrToRGB *ycbcr ;
   TIFFCIELabToRGB *cielab ;
   uint8 *UaToAa ;
   uint8 *Bitdepth16To8 ;
   int row_offset ;
   int col_offset ;
};
typedef int (*TIFFInitMethod)(TIFF * , int  );
struct __anonstruct_TIFFCodec_27 {
   char *name ;
   uint16 scheme ;
   int (*init)(TIFF * , int  ) ;
};
typedef struct __anonstruct_TIFFCodec_27 TIFFCodec;
typedef struct _IO_FILE FILE;
typedef struct _IO_FILE __FILE;
union __anonunion___value_29 {
   unsigned int __wch ;
   char __wchb[4] ;
};
struct __anonstruct___mbstate_t_28 {
   int __count ;
   union __anonunion___value_29 __value ;
};
typedef struct __anonstruct___mbstate_t_28 __mbstate_t;
struct __anonstruct__G_fpos_t_30 {
   __off_t __pos ;
   __mbstate_t __state ;
};
typedef struct __anonstruct__G_fpos_t_30 _G_fpos_t;
struct __anonstruct__G_fpos64_t_31 {
   __off64_t __pos ;
   __mbstate_t __state ;
};
typedef struct __anonstruct__G_fpos64_t_31 _G_fpos64_t;
typedef short _G_int16_t;
typedef int _G_int32_t;
typedef unsigned short _G_uint16_t;
typedef unsigned int _G_uint32_t;
typedef __builtin_va_list __gnuc_va_list;
struct _IO_jump_t;
typedef void _IO_lock_t;
struct _IO_marker {
   struct _IO_marker *_next ;
   struct _IO_FILE *_sbuf ;
   int _pos ;
};
enum __codecvt_result {
    __codecvt_ok = 0,
    __codecvt_partial = 1,
    __codecvt_error = 2,
    __codecvt_noconv = 3
} ;
struct _IO_FILE {
   int _flags ;
   char *_IO_read_ptr ;
   char *_IO_read_end ;
   char *_IO_read_base ;
   char *_IO_write_base ;
   char *_IO_write_ptr ;
   char *_IO_write_end ;
   char *_IO_buf_base ;
   char *_IO_buf_end ;
   char *_IO_save_base ;
   char *_IO_backup_base ;
   char *_IO_save_end ;
   struct _IO_marker *_markers ;
   struct _IO_FILE *_chain ;
   int _fileno ;
   int _flags2 ;
   __off_t _old_offset ;
   unsigned short _cur_column ;
   signed char _vtable_offset ;
   char _shortbuf[1] ;
   _IO_lock_t *_lock ;
   __off64_t _offset ;
   void *__pad1 ;
   void *__pad2 ;
   void *__pad3 ;
   void *__pad4 ;
   size_t __pad5 ;
   int _mode ;
   char _unused2[(15U * sizeof(int ) - 4U * sizeof(void *)) - sizeof(size_t )] ;
};
typedef struct _IO_FILE _IO_FILE;
struct _IO_FILE_plus;
typedef __ssize_t __io_read_fn(void *__cookie , char *__buf , size_t __nbytes );
typedef __ssize_t __io_write_fn(void *__cookie , char const   *__buf ,
                                size_t __n );
typedef int __io_seek_fn(void *__cookie , __off64_t *__pos , int __w );
typedef int __io_close_fn(void *__cookie );
typedef __gnuc_va_list va_list;
typedef _G_fpos64_t fpos_t;
typedef void (*TIFFErrorHandler)(char const   * , char const   * , va_list  );
typedef void (*TIFFErrorHandlerExt)(thandle_t  , char const   * ,
                                    char const   * , va_list  );
typedef tmsize_t (*TIFFReadWriteProc)(thandle_t  , void * , tmsize_t  );
typedef uint64 (*TIFFSeekProc)(thandle_t  , uint64  , int  );
typedef int (*TIFFCloseProc)(thandle_t  );
typedef uint64 (*TIFFSizeProc)(thandle_t  );
typedef int (*TIFFMapFileProc)(thandle_t  , void **base , tmsize_t *size );
typedef void (*TIFFUnmapFileProc)(thandle_t  , void *base , tmsize_t size );
typedef void (*TIFFExtendProc)(TIFF * );
struct _TIFFFieldInfoArray;
typedef struct _TIFFFieldInfoArray TIFFFieldInfoArray;
struct __anonstruct_TIFFFieldInfo_32 {
   ttag_t field_tag ;
   short field_readcount ;
   short field_writecount ;
   TIFFDataType field_type ;
   unsigned short field_bit ;
   unsigned char field_oktochange ;
   unsigned char field_passcount ;
   char *field_name ;
};
typedef struct __anonstruct_TIFFFieldInfo_32 TIFFFieldInfo;
typedef int (*TIFFVSetMethod)(TIFF * , uint32  , va_list  );
typedef int (*TIFFVGetMethod)(TIFF * , uint32  , va_list  );
typedef void (*TIFFPrintMethod)(TIFF * , FILE * , long  );
struct __anonstruct_TIFFTagMethods_33 {
   int (*vsetfield)(TIFF * , uint32  , va_list  ) ;
   int (*vgetfield)(TIFF * , uint32  , va_list  ) ;
   void (*printdir)(TIFF * , FILE * , long  ) ;
};
typedef struct __anonstruct_TIFFTagMethods_33 TIFFTagMethods;
struct __anonstruct_TIFFTagValue_34 {
   TIFFFieldInfo const   *info ;
   int count ;
   void *value ;
};
typedef struct __anonstruct_TIFFTagValue_34 TIFFTagValue;
struct __anonstruct_TIFFDirectory_35 {
   unsigned long td_fieldsset[4] ;
   uint32 td_imagewidth ;
   uint32 td_imagelength ;
   uint32 td_imagedepth ;
   uint32 td_tilewidth ;
   uint32 td_tilelength ;
   uint32 td_tiledepth ;
   uint32 td_subfiletype ;
   uint16 td_bitspersample ;
   uint16 td_sampleformat ;
   uint16 td_compression ;
   uint16 td_photometric ;
   uint16 td_threshholding ;
   uint16 td_fillorder ;
   uint16 td_orientation ;
   uint16 td_samplesperpixel ;
   uint32 td_rowsperstrip ;
   uint16 td_minsamplevalue ;
   uint16 td_maxsamplevalue ;
   double td_sminsamplevalue ;
   double td_smaxsamplevalue ;
   float td_xresolution ;
   float td_yresolution ;
   uint16 td_resolutionunit ;
   uint16 td_planarconfig ;
   float td_xposition ;
   float td_yposition ;
   uint16 td_pagenumber[2] ;
   uint16 *td_colormap[3] ;
   uint16 td_halftonehints[2] ;
   uint16 td_extrasamples ;
   uint16 *td_sampleinfo ;
   uint32 td_stripsperimage ;
   uint32 td_nstrips ;
   uint64 *td_stripoffset ;
   uint64 *td_stripbytecount ;
   int td_stripbytecountsorted ;
   uint16 td_nsubifd ;
   uint64 *td_subifd ;
   uint16 td_ycbcrsubsampling[2] ;
   uint16 td_ycbcrpositioning ;
   uint16 *td_transferfunction[3] ;
   int td_inknameslen ;
   char *td_inknames ;
   int td_customValueCount ;
   TIFFTagValue *td_customValues ;
};
typedef struct __anonstruct_TIFFDirectory_35 TIFFDirectory;
struct _TIFFField {
   uint32 field_tag ;
   short field_readcount ;
   short field_writecount ;
   TIFFDataType field_type ;
   uint32 reserved ;
   TIFFSetGetFieldType set_field_type ;
   TIFFSetGetFieldType get_field_type ;
   unsigned short field_bit ;
   unsigned char field_oktochange ;
   unsigned char field_passcount ;
   char *field_name ;
   struct _TIFFFieldInfoArray  const  *field_subfields ;
};
typedef struct _TIFFField TIFFField;
enum __anonenum_TIFFFieldInfoArrayType_36 {
    tfiatImage = 0,
    tfiatExif = 1,
    tfiatOther = 2
} ;
typedef enum __anonenum_TIFFFieldInfoArrayType_36 TIFFFieldInfoArrayType;
struct _TIFFFieldInfoArray {
   TIFFFieldInfoArrayType type ;
   uint32 allocated ;
   uint32 used ;
   TIFFField const   *fieldinfo ;
};
struct __anonstruct_TIFFDirEntry_37 {
   uint16 tdir_tag ;
   uint16 tdir_type ;
   uint64 tdir_count ;
   uint64 tdir_offset ;
};
typedef struct __anonstruct_TIFFDirEntry_37 TIFFDirEntry;
struct client_info {
   struct client_info *next ;
   void *data ;
   char *name ;
};
typedef struct client_info TIFFClientInfoLink;
typedef unsigned char tidataval_t;
typedef tidataval_t *tidata_t;
typedef void (*TIFFVoidMethod)(TIFF * );
typedef int (*TIFFBoolMethod)(TIFF * );
typedef int (*TIFFPreMethod)(TIFF * , uint16  );
typedef int (*TIFFCodeMethod)(TIFF *tif , uint8 *buf , tmsize_t size ,
                              uint16 sample );
typedef int (*TIFFSeekMethod)(TIFF * , uint32  );
typedef void (*TIFFPostMethod)(TIFF *tif , uint8 *buf , tmsize_t size );
typedef uint32 (*TIFFStripMethod)(TIFF * , uint32  );
typedef void (*TIFFTileMethod)(TIFF * , uint32 * , uint32 * );
union __anonunion_tif_header_38 {
   TIFFHeaderCommon common ;
   TIFFHeaderClassic classic ;
   TIFFHeaderBig big ;
};
struct tiff {
   char *tif_name ;
   int tif_fd ;
   int tif_mode ;
   uint32 tif_flags ;
   uint64 tif_diroff ;
   uint64 tif_nextdiroff ;
   uint64 *tif_dirlist ;
   uint16 tif_dirlistsize ;
   uint16 tif_dirnumber ;
   TIFFDirectory tif_dir ;
   TIFFDirectory tif_customdir ;
   union __anonunion_tif_header_38 tif_header ;
   uint16 tif_header_size ;
   uint32 tif_row ;
   uint16 tif_curdir ;
   uint32 tif_curstrip ;
   uint64 tif_curoff ;
   uint64 tif_dataoff ;
   uint16 tif_nsubifd ;
   uint64 tif_subifdoff ;
   uint32 tif_col ;
   uint32 tif_curtile ;
   tmsize_t tif_tilesize ;
   int tif_decodestatus ;
   int (*tif_fixuptags)(TIFF * ) ;
   int (*tif_setupdecode)(TIFF * ) ;
   int (*tif_predecode)(TIFF * , uint16  ) ;
   int (*tif_setupencode)(TIFF * ) ;
   int tif_encodestatus ;
   int (*tif_preencode)(TIFF * , uint16  ) ;
   int (*tif_postencode)(TIFF * ) ;
   int (*tif_decoderow)(TIFF *tif , uint8 *buf , tmsize_t size , uint16 sample ) ;
   int (*tif_encoderow)(TIFF *tif , uint8 *buf , tmsize_t size , uint16 sample ) ;
   int (*tif_decodestrip)(TIFF *tif , uint8 *buf , tmsize_t size ,
                          uint16 sample ) ;
   int (*tif_encodestrip)(TIFF *tif , uint8 *buf , tmsize_t size ,
                          uint16 sample ) ;
   int (*tif_decodetile)(TIFF *tif , uint8 *buf , tmsize_t size , uint16 sample ) ;
   int (*tif_encodetile)(TIFF *tif , uint8 *buf , tmsize_t size , uint16 sample ) ;
   void (*tif_close)(TIFF * ) ;
   int (*tif_seek)(TIFF * , uint32  ) ;
   void (*tif_cleanup)(TIFF * ) ;
   uint32 (*tif_defstripsize)(TIFF * , uint32  ) ;
   void (*tif_deftilesize)(TIFF * , uint32 * , uint32 * ) ;
   uint8 *tif_data ;
   tmsize_t tif_scanlinesize ;
   tmsize_t tif_scanlineskew ;
   uint8 *tif_rawdata ;
   tmsize_t tif_rawdatasize ;
   uint8 *tif_rawcp ;
   tmsize_t tif_rawcc ;
   uint8 *tif_base ;
   tmsize_t tif_size ;
   int (*tif_mapproc)(thandle_t  , void **base , tmsize_t *size ) ;
   void (*tif_unmapproc)(thandle_t  , void *base , tmsize_t size ) ;
   thandle_t tif_clientdata ;
   tmsize_t (*tif_readproc)(thandle_t  , void * , tmsize_t  ) ;
   tmsize_t (*tif_writeproc)(thandle_t  , void * , tmsize_t  ) ;
   uint64 (*tif_seekproc)(thandle_t  , uint64  , int  ) ;
   int (*tif_closeproc)(thandle_t  ) ;
   uint64 (*tif_sizeproc)(thandle_t  ) ;
   void (*tif_postdecode)(TIFF *tif , uint8 *buf , tmsize_t size ) ;
   TIFFField **tif_fieldinfo ;
   uint32 tif_nfields ;
   TIFFField const   *tif_foundfield ;
   TIFFTagMethods tif_tagmethods ;
   TIFFClientInfoLink *tif_clientinfo ;
};
typedef long wchar_t;
struct __anonstruct___wait_terminated_39 {
   unsigned int __w_termsig : 7 ;
   unsigned int __w_coredump : 1 ;
   unsigned int __w_retcode : 8 ;
   unsigned int  : 16 ;
};
struct __anonstruct___wait_stopped_40 {
   unsigned int __w_stopval : 8 ;
   unsigned int __w_stopsig : 8 ;
   unsigned int  : 16 ;
};
union wait {
   int w_status ;
   struct __anonstruct___wait_terminated_39 __wait_terminated ;
   struct __anonstruct___wait_stopped_40 __wait_stopped ;
};
union __anonunion___WAIT_STATUS_41 {
   union wait *__uptr ;
   int *__iptr ;
};
typedef union __anonunion___WAIT_STATUS_41  __attribute__((__transparent_union__)) __WAIT_STATUS;
struct __anonstruct_div_t_42 {
   int quot ;
   int rem ;
};
typedef struct __anonstruct_div_t_42 div_t;
struct __anonstruct_ldiv_t_43 {
   long quot ;
   long rem ;
};
typedef struct __anonstruct_ldiv_t_43 ldiv_t;
struct __anonstruct_lldiv_t_44 {
   long long quot ;
   long long rem ;
};
typedef struct __anonstruct_lldiv_t_44 lldiv_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 long double float_t;
typedef long double double_t;
enum __anonenum_45 {
    FP_NAN = 0,
    FP_INFINITE = 1,
    FP_ZERO = 2,
    FP_SUBNORMAL = 3,
    FP_NORMAL = 4
} ;
enum __anonenum__LIB_VERSION_TYPE_46 {
    _IEEE_ = -1,
    _SVID_ = 0,
    _XOPEN_ = 1,
    _POSIX_ = 2,
    _ISOC_ = 3
} ;
typedef enum __anonenum__LIB_VERSION_TYPE_46 _LIB_VERSION_TYPE;
struct exception {
   int type ;
   char *name ;
   double arg1 ;
   double arg2 ;
   double retval ;
};
union __anonunion___u_47 {
   float __f ;
   int __i ;
};
union __anonunion___u_48 {
   double __d ;
   int __i[2] ;
};
union __anonunion___u_49 {
   long double __l ;
   int __i[3] ;
};
union __anonunion___n_50 {
   long double __xld ;
   unsigned int __xi[3] ;
};
union __anonunion_51 {
   double __d ;
   int __i[2] ;
};
struct logLuvState;
typedef struct logLuvState LogLuvState;
struct logLuvState {
   int user_datafmt ;
   int encode_meth ;
   int pixel_size ;
   uint8 *tbuf ;
   tmsize_t tbuflen ;
   void (*tfunc)(LogLuvState * , uint8 * , tmsize_t  ) ;
   int (*vgetparent)(TIFF * , uint32  , va_list  ) ;
   int (*vsetparent)(TIFF * , uint32  , va_list  ) ;
};
struct __anonstruct_uv_row_52 {
   float ustart ;
   short nus ;
   short ncum ;
};
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 ) ;
extern FILE *fopen(char const   * __restrict  __filename ,
                   char const   * __restrict  __modes )  __asm__("fopen64")  ;
extern int fprintf(FILE * __restrict  __stream ,
                   char const   * __restrict  __format  , ...) ;
extern int fflush(FILE *__stream ) ;
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_major(unsigned long long __dev ) ;
__inline extern unsigned int gnu_dev_major(unsigned long long __dev ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "9995\n");
  fflush(_coverage_fout);
  }
  return ((unsigned int )(((__dev >> 8) & 4095ULL) | (unsigned long long )((unsigned int )(__dev >> 32) & 4294963200U)));
}
}
__inline extern  __attribute__((__nothrow__)) unsigned int gnu_dev_minor(unsigned long long __dev ) ;
__inline extern unsigned int gnu_dev_minor(unsigned long long __dev ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "9996\n");
  fflush(_coverage_fout);
  }
  return ((unsigned int )((__dev & 255ULL) | (unsigned long long )((unsigned int )(__dev >> 12) & 4294967040U)));
}
}
__inline extern  __attribute__((__nothrow__)) unsigned long long gnu_dev_makedev(unsigned int __major ,
                                                                                 unsigned int __minor ) ;
__inline extern unsigned long long gnu_dev_makedev(unsigned int __major ,
                                                   unsigned int __minor ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "9997\n");
  fflush(_coverage_fout);
  }
  return (((unsigned long long )((__minor & 255U) | ((__major & 4095U) << 8)) | ((unsigned long long )(__minor & 4294967040U) << 12)) | ((unsigned long long )(__major & 4294963200U) << 32));
}
}
extern int fcntl(int __fd , int __cmd  , ...) ;
extern int open(char const   *__file , int __oflag  , ...)  __asm__("open64") __attribute__((__nonnull__(1))) ;
extern int openat(int __fd , char const   *__file , int __oflag  , ...)  __asm__("openat64") __attribute__((__nonnull__(2))) ;
extern int creat(char const   *__file , __mode_t __mode )  __asm__("creat64") __attribute__((__nonnull__(1))) ;
extern int lockf(int __fd , int __cmd , __off64_t __len )  __asm__("lockf64")  ;
extern  __attribute__((__nothrow__)) int posix_fadvise(int __fd ,
                                                       __off64_t __offset ,
                                                       __off64_t __len ,
                                                       int __advise )  __asm__("posix_fadvise64")  ;
extern int posix_fallocate(int __fd , __off64_t __offset , __off64_t __len )  __asm__("posix_fallocate64")  ;
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__)) 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__)) 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__)) 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__)) int strerror_r(int __errnum , char *__buf ,
                                                    size_t __buflen )  __asm__("__xpg_strerror_r") __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 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__)) 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 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 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10002\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "10003\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10000\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      fprintf(_coverage_fout, "9999\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject) {
        {
        fprintf(_coverage_fout, "9998\n");
        fflush(_coverage_fout);
        }

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10010\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "10011\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10008\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      fprintf(_coverage_fout, "10007\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        fprintf(_coverage_fout, "10006\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          fprintf(_coverage_fout, "10005\n");
          fflush(_coverage_fout);
          }

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10019\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "10020\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10017\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) != 0) {
      {
      fprintf(_coverage_fout, "10016\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(__s + __result) != (int const   )__reject1) {
        {
        fprintf(_coverage_fout, "10015\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*(__s + __result) != (int const   )__reject2) {
          {
          fprintf(_coverage_fout, "10014\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*(__s + __result) != (int const   )__reject3) {
            {
            fprintf(_coverage_fout, "10013\n");
            fflush(_coverage_fout);
            }

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10025\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "10026\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10023\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept) {
      {
      fprintf(_coverage_fout, "10022\n");
      fflush(_coverage_fout);
      }

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10033\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "10034\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10031\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      fprintf(_coverage_fout, "10028\n");
      fflush(_coverage_fout);
      }

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

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10043\n");
  fflush(_coverage_fout);
  }
  __result = (size_t )0;
  {
  fprintf(_coverage_fout, "10044\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10041\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(__s + __result) == (int const   )__accept1) {
      {
      fprintf(_coverage_fout, "10036\n");
      fflush(_coverage_fout);
      }

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

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

        } else {
          break;
        }
      }
    }
    {
    fprintf(_coverage_fout, "10042\n");
    fflush(_coverage_fout);
    }
    __result ++;
  }
  {
  fprintf(_coverage_fout, "10045\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
__inline extern char *__strpbrk_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) ;
__inline extern char *__strpbrk_c2(char const   *__s , int __accept1 ,
                                   int __accept2 ) 
{ char *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10053\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10049\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      fprintf(_coverage_fout, "10048\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        fprintf(_coverage_fout, "10047\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          fprintf(_coverage_fout, "10046\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10050\n");
    fflush(_coverage_fout);
    }
    __s ++;
  }
  {
  fprintf(_coverage_fout, "10054\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    fprintf(_coverage_fout, "10051\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    fprintf(_coverage_fout, "10052\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  fprintf(_coverage_fout, "10055\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern char *__strpbrk_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) ;
__inline extern char *__strpbrk_c3(char const   *__s , int __accept1 ,
                                   int __accept2 , int __accept3 ) 
{ char *tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10064\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10060\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*__s != 0) {
      {
      fprintf(_coverage_fout, "10059\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*__s != (int const   )__accept1) {
        {
        fprintf(_coverage_fout, "10058\n");
        fflush(_coverage_fout);
        }
        if ((int const   )*__s != (int const   )__accept2) {
          {
          fprintf(_coverage_fout, "10057\n");
          fflush(_coverage_fout);
          }
          if ((int const   )*__s != (int const   )__accept3) {
            {
            fprintf(_coverage_fout, "10056\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
        } else {
          break;
        }
      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10061\n");
    fflush(_coverage_fout);
    }
    __s ++;
  }
  {
  fprintf(_coverage_fout, "10065\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*__s == 0) {
    {
    fprintf(_coverage_fout, "10062\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((void *)0);
  } else {
    {
    fprintf(_coverage_fout, "10063\n");
    fflush(_coverage_fout);
    }
    tmp = (char *)((unsigned int )__s);
  }
  {
  fprintf(_coverage_fout, "10066\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern char *__strtok_r_1c(char *__s , char __sep , char **__nextp ) ;
__inline extern char *__strtok_r_1c(char *__s , char __sep , char **__nextp ) 
{ char *__result ;
  char *tmp ;
  char *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10084\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__s == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10067\n");
    fflush(_coverage_fout);
    }
    __s = *__nextp;
  } else {
    {
    fprintf(_coverage_fout, "10068\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10085\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10070\n");
    fflush(_coverage_fout);
    }
    if ((int )*__s == (int )__sep) {
      {
      fprintf(_coverage_fout, "10069\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10071\n");
    fflush(_coverage_fout);
    }
    __s ++;
  }
  {
  fprintf(_coverage_fout, "10086\n");
  fflush(_coverage_fout);
  }
  __result = (char *)((void *)0);
  {
  fprintf(_coverage_fout, "10087\n");
  fflush(_coverage_fout);
  }
  if ((int )*__s != 0) {
    {
    fprintf(_coverage_fout, "10079\n");
    fflush(_coverage_fout);
    }
    tmp = __s;
    {
    fprintf(_coverage_fout, "10080\n");
    fflush(_coverage_fout);
    }
    __s ++;
    {
    fprintf(_coverage_fout, "10081\n");
    fflush(_coverage_fout);
    }
    __result = tmp;
    {
    fprintf(_coverage_fout, "10082\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10075\n");
      fflush(_coverage_fout);
      }
      if ((int )*__s != 0) {
        {
        fprintf(_coverage_fout, "10072\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10076\n");
      fflush(_coverage_fout);
      }
      tmp___0 = __s;
      {
      fprintf(_coverage_fout, "10077\n");
      fflush(_coverage_fout);
      }
      __s ++;
      {
      fprintf(_coverage_fout, "10078\n");
      fflush(_coverage_fout);
      }
      if ((int )*tmp___0 == (int )__sep) {
        {
        fprintf(_coverage_fout, "10073\n");
        fflush(_coverage_fout);
        }
        *(__s + -1) = (char )'\000';
        break;
      } else {
        {
        fprintf(_coverage_fout, "10074\n");
        fflush(_coverage_fout);
        }

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

  }
  {
  fprintf(_coverage_fout, "10088\n");
  fflush(_coverage_fout);
  }
  *__nextp = __s;
  {
  fprintf(_coverage_fout, "10089\n");
  fflush(_coverage_fout);
  }
  return (__result);
}
}
extern char *__strsep_g(char **__stringp , char const   *__delim ) ;
__inline extern char *__strsep_1c(char **__s , char __reject ) ;
__inline extern char *__strsep_1c(char **__s , char __reject ) 
{ register char *__retval ;
  char *tmp ;
  char *tmp___0 ;
  void *tmp___1 ;
  char *tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10099\n");
  fflush(_coverage_fout);
  }
  __retval = *__s;
  {
  fprintf(_coverage_fout, "10100\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10094\n");
    fflush(_coverage_fout);
    }
    tmp___2 = __builtin_strchr(__retval, (int )__reject);
    {
    fprintf(_coverage_fout, "10095\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp___2;
    {
    fprintf(_coverage_fout, "10096\n");
    fflush(_coverage_fout);
    }
    *__s = tmp___0;
    {
    fprintf(_coverage_fout, "10097\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )tmp___0 != (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "10090\n");
      fflush(_coverage_fout);
      }
      tmp = *__s;
      {
      fprintf(_coverage_fout, "10091\n");
      fflush(_coverage_fout);
      }
      (*__s) ++;
      {
      fprintf(_coverage_fout, "10092\n");
      fflush(_coverage_fout);
      }
      *tmp = (char )'\000';
    } else {
      {
      fprintf(_coverage_fout, "10093\n");
      fflush(_coverage_fout);
      }

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

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10119\n");
  fflush(_coverage_fout);
  }
  __retval = *__s;
  {
  fprintf(_coverage_fout, "10120\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10115\n");
    fflush(_coverage_fout);
    }
    __cp = __retval;
    {
    fprintf(_coverage_fout, "10116\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10112\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        fprintf(_coverage_fout, "10102\n");
        fflush(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        fprintf(_coverage_fout, "10103\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "10113\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        fprintf(_coverage_fout, "10104\n");
        fflush(_coverage_fout);
        }
        tmp = __cp;
        {
        fprintf(_coverage_fout, "10105\n");
        fflush(_coverage_fout);
        }
        __cp ++;
        {
        fprintf(_coverage_fout, "10106\n");
        fflush(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        fprintf(_coverage_fout, "10111\n");
        fflush(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          fprintf(_coverage_fout, "10107\n");
          fflush(_coverage_fout);
          }
          tmp = __cp;
          {
          fprintf(_coverage_fout, "10108\n");
          fflush(_coverage_fout);
          }
          __cp ++;
          {
          fprintf(_coverage_fout, "10109\n");
          fflush(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          fprintf(_coverage_fout, "10110\n");
          fflush(_coverage_fout);
          }

        }
      }
      {
      fprintf(_coverage_fout, "10114\n");
      fflush(_coverage_fout);
      }
      __cp ++;
    }
    {
    fprintf(_coverage_fout, "10117\n");
    fflush(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    fprintf(_coverage_fout, "10118\n");
    fflush(_coverage_fout);
    }

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

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10143\n");
  fflush(_coverage_fout);
  }
  __retval = *__s;
  {
  fprintf(_coverage_fout, "10144\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )__retval != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10139\n");
    fflush(_coverage_fout);
    }
    __cp = __retval;
    {
    fprintf(_coverage_fout, "10140\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10136\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == 0) {
        {
        fprintf(_coverage_fout, "10122\n");
        fflush(_coverage_fout);
        }
        __cp = (char *)((void *)0);
        break;
      } else {
        {
        fprintf(_coverage_fout, "10123\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "10137\n");
      fflush(_coverage_fout);
      }
      if ((int )*__cp == (int )__reject1) {
        {
        fprintf(_coverage_fout, "10124\n");
        fflush(_coverage_fout);
        }
        tmp = __cp;
        {
        fprintf(_coverage_fout, "10125\n");
        fflush(_coverage_fout);
        }
        __cp ++;
        {
        fprintf(_coverage_fout, "10126\n");
        fflush(_coverage_fout);
        }
        *tmp = (char )'\000';
        break;
      } else {
        {
        fprintf(_coverage_fout, "10135\n");
        fflush(_coverage_fout);
        }
        if ((int )*__cp == (int )__reject2) {
          {
          fprintf(_coverage_fout, "10127\n");
          fflush(_coverage_fout);
          }
          tmp = __cp;
          {
          fprintf(_coverage_fout, "10128\n");
          fflush(_coverage_fout);
          }
          __cp ++;
          {
          fprintf(_coverage_fout, "10129\n");
          fflush(_coverage_fout);
          }
          *tmp = (char )'\000';
          break;
        } else {
          {
          fprintf(_coverage_fout, "10134\n");
          fflush(_coverage_fout);
          }
          if ((int )*__cp == (int )__reject3) {
            {
            fprintf(_coverage_fout, "10130\n");
            fflush(_coverage_fout);
            }
            tmp = __cp;
            {
            fprintf(_coverage_fout, "10131\n");
            fflush(_coverage_fout);
            }
            __cp ++;
            {
            fprintf(_coverage_fout, "10132\n");
            fflush(_coverage_fout);
            }
            *tmp = (char )'\000';
            break;
          } else {
            {
            fprintf(_coverage_fout, "10133\n");
            fflush(_coverage_fout);
            }

          }
        }
      }
      {
      fprintf(_coverage_fout, "10138\n");
      fflush(_coverage_fout);
      }
      __cp ++;
    }
    {
    fprintf(_coverage_fout, "10141\n");
    fflush(_coverage_fout);
    }
    *__s = __cp;
  } else {
    {
    fprintf(_coverage_fout, "10142\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10145\n");
  fflush(_coverage_fout);
  }
  return (__retval);
}
}
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__)) char *__strdup(char const   *__string )  __attribute__((__malloc__)) ;
extern  __attribute__((__nothrow__)) char *__strndup(char const   *__string ,
                                                     size_t __n )  __attribute__((__malloc__)) ;
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  __attribute__((__nothrow__)) void insque(void *__elem , void *__prev ) ;
extern  __attribute__((__nothrow__)) void remque(void *__elem ) ;
extern  __attribute__((__nothrow__)) ENTRY *hsearch(ENTRY __item ,
                                                    ACTION __action ) ;
extern  __attribute__((__nothrow__)) int hcreate(size_t __nel ) ;
extern  __attribute__((__nothrow__)) void hdestroy(void) ;
extern void *tsearch(void const   *__key , void **__rootp ,
                     int (*__compar)(void const   * , void const   * ) ) ;
extern void *tfind(void const   *__key , void * const  *__rootp ,
                   int (*__compar)(void const   * , void const   * ) ) ;
extern void *tdelete(void const   * __restrict  __key ,
                     void ** __restrict  __rootp ,
                     int (*__compar)(void const   * , void const   * ) ) ;
extern void twalk(void const   *__root ,
                  void (*__action)(void const   *__nodep , VISIT __value ,
                                   int __level ) ) ;
extern void *lfind(void const   *__key , void const   *__base ,
                   size_t *__nmemb , size_t __size ,
                   int (*__compar)(void const   * , void const   * ) ) ;
extern void *lsearch(void const   *__key , void *__base , size_t *__nmemb ,
                     size_t __size , int (*__compar)(void const   * ,
                                                     void const   * ) ) ;
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 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)  __asm__("tmpfile64")  ;
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_unlocked(FILE *__stream ) ;
extern FILE *freopen(char const   * __restrict  __filename ,
                     char const   * __restrict  __modes ,
                     FILE * __restrict  __stream )  __asm__("freopen64")  ;
extern  __attribute__((__nothrow__)) FILE *fdopen(int __fd ,
                                                  char const   *__modes ) ;
extern  __attribute__((__nothrow__)) FILE *fmemopen(void *__s , size_t __len ,
                                                    char const   *__modes ) ;
extern  __attribute__((__nothrow__)) FILE *open_memstream(char **__bufloc ,
                                                          size_t *__sizeloc ) ;
extern  __attribute__((__nothrow__)) void setbuf(FILE * __restrict  __stream ,
                                                 char * __restrict  __buf ) ;
extern  __attribute__((__nothrow__)) int setvbuf(FILE * __restrict  __stream ,
                                                 char * __restrict  __buf ,
                                                 int __modes , size_t __n ) ;
extern  __attribute__((__nothrow__)) void setbuffer(FILE * __restrict  __stream ,
                                                    char * __restrict  __buf ,
                                                    size_t __size ) ;
extern  __attribute__((__nothrow__)) void setlinebuf(FILE *__stream ) ;
extern int printf(char const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) int sprintf(char * __restrict  __s ,
                                                 char const   * __restrict  __format 
                                                 , ...) ;
extern int vfprintf(FILE * __restrict  __s ,
                    char const   * __restrict  __format , __gnuc_va_list __arg ) ;
__inline extern int vprintf(char const   * __restrict  __fmt ,
                            __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int vsprintf(char * __restrict  __s ,
                                                  char const   * __restrict  __format ,
                                                  __gnuc_va_list __arg ) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  snprintf)(char * __restrict  __s ,
                                                                             size_t __maxlen ,
                                                                             char const   * __restrict  __format 
                                                                             , ...) ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vsnprintf)(char * __restrict  __s ,
                                                                              size_t __maxlen ,
                                                                              char const   * __restrict  __format ,
                                                                              __gnuc_va_list __arg ) ;
extern 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  , ...)  __asm__("__isoc99_fscanf")  ;
extern int scanf(char const   * __restrict  __format  , ...)  __asm__("__isoc99_scanf")  ;
extern  __attribute__((__nothrow__)) int sscanf(char const   * __restrict  __s ,
                                                char const   * __restrict  __format 
                                                , ...)  __asm__("__isoc99_sscanf")  ;
extern int ( /* format attribute */  vfscanf)(FILE * __restrict  __s ,
                                              char const   * __restrict  __format ,
                                              __gnuc_va_list __arg )  __asm__("__isoc99_vfscanf")  ;
extern int ( /* format attribute */  vscanf)(char const   * __restrict  __format ,
                                             __gnuc_va_list __arg )  __asm__("__isoc99_vscanf")  ;
extern  __attribute__((__nothrow__)) int ( /* format attribute */  vsscanf)(char const   * __restrict  __s ,
                                                                            char const   * __restrict  __format ,
                                                                            __gnuc_va_list __arg )  __asm__("__isoc99_vsscanf")  ;
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 __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 ) ;
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 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 , __off64_t __off , int __whence )  __asm__("fseeko64")  ;
extern __off64_t ftello(FILE *__stream )  __asm__("ftello64")  ;
extern int fgetpos(FILE * __restrict  __stream , fpos_t * __restrict  __pos )  __asm__("fgetpos64")  ;
extern int fsetpos(FILE *__stream , fpos_t const   *__pos )  __asm__("fsetpos64")  ;
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  __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  __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 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10146\n");
  fflush(_coverage_fout);
  }
  tmp = vfprintf((FILE */* __restrict  */)stdout, __fmt, __arg);
  {
  fprintf(_coverage_fout, "10147\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int getchar(void) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10148\n");
  fflush(_coverage_fout);
  }
  tmp = _IO_getc(stdin);
  {
  fprintf(_coverage_fout, "10149\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int fgetc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10155\n");
  fflush(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end),
                             0L);
  {
  fprintf(_coverage_fout, "10156\n");
  fflush(_coverage_fout);
  }
  if (tmp___3) {
    {
    fprintf(_coverage_fout, "10150\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    fprintf(_coverage_fout, "10151\n");
    fflush(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "10152\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    fprintf(_coverage_fout, "10153\n");
    fflush(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    fprintf(_coverage_fout, "10154\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  fprintf(_coverage_fout, "10157\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int getc_unlocked(FILE *__fp ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10163\n");
  fflush(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )__fp->_IO_read_ptr >= (unsigned int )__fp->_IO_read_end),
                             0L);
  {
  fprintf(_coverage_fout, "10164\n");
  fflush(_coverage_fout);
  }
  if (tmp___3) {
    {
    fprintf(_coverage_fout, "10158\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __uflow(__fp);
    {
    fprintf(_coverage_fout, "10159\n");
    fflush(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "10160\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __fp->_IO_read_ptr;
    {
    fprintf(_coverage_fout, "10161\n");
    fflush(_coverage_fout);
    }
    (__fp->_IO_read_ptr) ++;
    {
    fprintf(_coverage_fout, "10162\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  fprintf(_coverage_fout, "10165\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int getchar_unlocked(void) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  int tmp___2 ;
  long tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10171\n");
  fflush(_coverage_fout);
  }
  tmp___3 = __builtin_expect((long )((unsigned int )stdin->_IO_read_ptr >= (unsigned int )stdin->_IO_read_end),
                             0L);
  {
  fprintf(_coverage_fout, "10172\n");
  fflush(_coverage_fout);
  }
  if (tmp___3) {
    {
    fprintf(_coverage_fout, "10166\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __uflow(stdin);
    {
    fprintf(_coverage_fout, "10167\n");
    fflush(_coverage_fout);
    }
    tmp___2 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "10168\n");
    fflush(_coverage_fout);
    }
    tmp___1 = stdin->_IO_read_ptr;
    {
    fprintf(_coverage_fout, "10169\n");
    fflush(_coverage_fout);
    }
    (stdin->_IO_read_ptr) ++;
    {
    fprintf(_coverage_fout, "10170\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (int )*((unsigned char *)tmp___1);
  }
  {
  fprintf(_coverage_fout, "10173\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
}
}
__inline extern int putchar(int __c ) 
{ int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10174\n");
  fflush(_coverage_fout);
  }
  tmp = _IO_putc(__c, stdout);
  {
  fprintf(_coverage_fout, "10175\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern int fputc_unlocked(int __c , FILE *__stream ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10183\n");
  fflush(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end),
                             0L);
  {
  fprintf(_coverage_fout, "10184\n");
  fflush(_coverage_fout);
  }
  if (tmp___4) {
    {
    fprintf(_coverage_fout, "10176\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    fprintf(_coverage_fout, "10177\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "10178\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    fprintf(_coverage_fout, "10179\n");
    fflush(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    fprintf(_coverage_fout, "10180\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    fprintf(_coverage_fout, "10181\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    fprintf(_coverage_fout, "10182\n");
    fflush(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  fprintf(_coverage_fout, "10185\n");
  fflush(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern int putc_unlocked(int __c , FILE *__stream ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10193\n");
  fflush(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )__stream->_IO_write_ptr >= (unsigned int )__stream->_IO_write_end),
                             0L);
  {
  fprintf(_coverage_fout, "10194\n");
  fflush(_coverage_fout);
  }
  if (tmp___4) {
    {
    fprintf(_coverage_fout, "10186\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __overflow(__stream, (int )((unsigned char )__c));
    {
    fprintf(_coverage_fout, "10187\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "10188\n");
    fflush(_coverage_fout);
    }
    tmp___1 = __stream->_IO_write_ptr;
    {
    fprintf(_coverage_fout, "10189\n");
    fflush(_coverage_fout);
    }
    (__stream->_IO_write_ptr) ++;
    {
    fprintf(_coverage_fout, "10190\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    fprintf(_coverage_fout, "10191\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    fprintf(_coverage_fout, "10192\n");
    fflush(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  fprintf(_coverage_fout, "10195\n");
  fflush(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern int putchar_unlocked(int __c ) 
{ long tmp ;
  int tmp___0 ;
  char *tmp___1 ;
  char tmp___2 ;
  int tmp___3 ;
  long tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10203\n");
  fflush(_coverage_fout);
  }
  tmp___4 = __builtin_expect((long )((unsigned int )stdout->_IO_write_ptr >= (unsigned int )stdout->_IO_write_end),
                             0L);
  {
  fprintf(_coverage_fout, "10204\n");
  fflush(_coverage_fout);
  }
  if (tmp___4) {
    {
    fprintf(_coverage_fout, "10196\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __overflow(stdout, (int )((unsigned char )__c));
    {
    fprintf(_coverage_fout, "10197\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "10198\n");
    fflush(_coverage_fout);
    }
    tmp___1 = stdout->_IO_write_ptr;
    {
    fprintf(_coverage_fout, "10199\n");
    fflush(_coverage_fout);
    }
    (stdout->_IO_write_ptr) ++;
    {
    fprintf(_coverage_fout, "10200\n");
    fflush(_coverage_fout);
    }
    tmp___2 = (char )__c;
    {
    fprintf(_coverage_fout, "10201\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = tmp___2;
    {
    fprintf(_coverage_fout, "10202\n");
    fflush(_coverage_fout);
    }
    tmp___3 = (int )((unsigned char )tmp___2);
  }
  {
  fprintf(_coverage_fout, "10205\n");
  fflush(_coverage_fout);
  }
  return (tmp___3);
}
}
__inline extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
__inline extern int feof_unlocked(FILE *__stream ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10206\n");
  fflush(_coverage_fout);
  }
  return ((__stream->_flags & 0x10) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) int ferror_unlocked(FILE *__stream ) ;
__inline extern int ferror_unlocked(FILE *__stream ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10207\n");
  fflush(_coverage_fout);
  }
  return ((__stream->_flags & 0x20) != 0);
}
}
extern char const   *TIFFGetVersion(void) ;
extern TIFFCodec const   *TIFFFindCODEC(uint16  ) ;
extern TIFFCodec *TIFFRegisterCODEC(uint16  , char const   * ,
                                    int (*)(TIFF * , int  ) ) ;
extern void TIFFUnRegisterCODEC(TIFFCodec * ) ;
extern int TIFFIsCODECConfigured(uint16  ) ;
extern TIFFCodec *TIFFGetConfiguredCODECs(void) ;
extern void *_TIFFmalloc(tmsize_t s ) ;
extern void *_TIFFrealloc(void *p , tmsize_t s ) ;
extern void _TIFFmemset(void *p , int v , tmsize_t c ) ;
extern void _TIFFmemcpy(void *d , void const   *s , tmsize_t c ) ;
extern int _TIFFmemcmp(void const   *p1 , void const   *p2 , tmsize_t c ) ;
extern void _TIFFfree(void *p ) ;
extern int TIFFGetTagListCount(TIFF * ) ;
extern uint32 TIFFGetTagListEntry(TIFF * , int tag_index ) ;
extern void TIFFMergeFieldInfo(TIFF *tif , TIFFFieldInfo const   *info ,
                               uint32 n ) ;
extern TIFFFieldInfo const   *TIFFFindFieldInfo(TIFF * , uint32  ,
                                                TIFFDataType  ) ;
extern TIFFFieldInfo const   *TIFFFindFieldInfoByName(TIFF * , char const   * ,
                                                      TIFFDataType  ) ;
extern TIFFFieldInfo const   *TIFFFieldWithTag(TIFF * , uint32  ) ;
extern TIFFFieldInfo const   *TIFFFieldWithName(TIFF * , char const   * ) ;
extern TIFFTagMethods *TIFFAccessTagMethods(TIFF * ) ;
extern void *TIFFGetClientInfo(TIFF * , char const   * ) ;
extern void TIFFSetClientInfo(TIFF * , void * , char const   * ) ;
extern void TIFFCleanup(TIFF *tif ) ;
extern void TIFFClose(TIFF *tif ) ;
extern int TIFFFlush(TIFF *tif ) ;
extern int TIFFFlushData(TIFF *tif ) ;
extern int TIFFGetField(TIFF *tif , uint32 tag  , ...) ;
extern int TIFFVGetField(TIFF *tif , uint32 tag , va_list ap ) ;
extern int TIFFGetFieldDefaulted(TIFF *tif , uint32 tag  , ...) ;
extern int TIFFVGetFieldDefaulted(TIFF *tif , uint32 tag , va_list ap ) ;
extern int TIFFReadDirectory(TIFF *tif ) ;
extern int TIFFReadCustomDirectory(TIFF *tif , uint64 diroff ,
                                   TIFFFieldInfoArray const   *infoarray ) ;
extern int TIFFReadEXIFDirectory(TIFF *tif , uint64 diroff ) ;
extern uint64 TIFFScanlineSize64(TIFF *tif ) ;
extern tmsize_t TIFFScanlineSize(TIFF *tif ) ;
extern uint64 TIFFRasterScanlineSize64(TIFF *tif ) ;
extern tmsize_t TIFFRasterScanlineSize(TIFF *tif ) ;
extern uint64 TIFFStripSize64(TIFF *tif ) ;
extern tmsize_t TIFFStripSize(TIFF *tif ) ;
extern uint64 TIFFRawStripSize64(TIFF *tif , uint32 strip ) ;
extern tmsize_t TIFFRawStripSize(TIFF *tif , uint32 strip ) ;
extern uint64 TIFFVStripSize64(TIFF *tif , uint32 nrows ) ;
extern tmsize_t TIFFVStripSize(TIFF *tif , uint32 nrows ) ;
extern uint64 TIFFTileRowSize64(TIFF *tif ) ;
extern tmsize_t TIFFTileRowSize(TIFF *tif ) ;
extern uint64 TIFFTileSize64(TIFF *tif ) ;
extern tmsize_t TIFFTileSize(TIFF *tif ) ;
extern uint64 TIFFVTileSize64(TIFF *tif , uint32 nrows ) ;
extern tmsize_t TIFFVTileSize(TIFF *tif , uint32 nrows ) ;
extern uint32 TIFFDefaultStripSize(TIFF *tif , uint32 request ) ;
extern void TIFFDefaultTileSize(TIFF * , uint32 * , uint32 * ) ;
extern int TIFFFileno(TIFF * ) ;
extern int TIFFSetFileno(TIFF * , int  ) ;
extern thandle_t TIFFClientdata(TIFF * ) ;
extern thandle_t TIFFSetClientdata(TIFF * , thandle_t  ) ;
extern int TIFFGetMode(TIFF * ) ;
extern int TIFFSetMode(TIFF * , int  ) ;
extern int TIFFIsTiled(TIFF * ) ;
extern int TIFFIsByteSwapped(TIFF * ) ;
extern int TIFFIsUpSampled(TIFF * ) ;
extern int TIFFIsMSB2LSB(TIFF * ) ;
extern int TIFFIsBigEndian(TIFF * ) ;
extern TIFFReadWriteProc TIFFGetReadProc(TIFF * ) ;
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF * ) ;
extern TIFFSeekProc TIFFGetSeekProc(TIFF * ) ;
extern TIFFCloseProc TIFFGetCloseProc(TIFF * ) ;
extern TIFFSizeProc TIFFGetSizeProc(TIFF * ) ;
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF * ) ;
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF * ) ;
extern uint32 TIFFCurrentRow(TIFF * ) ;
extern uint16 TIFFCurrentDirectory(TIFF * ) ;
extern uint16 TIFFNumberOfDirectories(TIFF * ) ;
extern uint64 TIFFCurrentDirOffset(TIFF * ) ;
extern uint32 TIFFCurrentStrip(TIFF * ) ;
extern uint32 TIFFCurrentTile(TIFF *tif ) ;
extern int TIFFReadBufferSetup(TIFF *tif , void *bp , tmsize_t size ) ;
extern int TIFFWriteBufferSetup(TIFF *tif , void *bp , tmsize_t size ) ;
extern int TIFFSetupStrips(TIFF * ) ;
extern int TIFFWriteCheck(TIFF * , int  , char const   * ) ;
extern void TIFFFreeDirectory(TIFF * ) ;
extern int TIFFCreateDirectory(TIFF * ) ;
extern int TIFFLastDirectory(TIFF * ) ;
extern int TIFFSetDirectory(TIFF * , uint16  ) ;
extern int TIFFSetSubDirectory(TIFF * , uint64  ) ;
extern int TIFFUnlinkDirectory(TIFF * , uint16  ) ;
extern int TIFFSetField(TIFF * , uint32   , ...) ;
extern int TIFFVSetField(TIFF * , uint32  , va_list  ) ;
extern int TIFFWriteDirectory(TIFF * ) ;
extern int TIFFCheckpointDirectory(TIFF * ) ;
extern int TIFFRewriteDirectory(TIFF * ) ;
extern void TIFFPrintDirectory(TIFF * , FILE * , long  ) ;
extern int TIFFReadScanline(TIFF *tif , void *buf , uint32 row , uint16 sample ) ;
extern int TIFFWriteScanline(TIFF *tif , void *buf , uint32 row , uint16 sample ) ;
extern int TIFFReadRGBAImage(TIFF * , uint32  , uint32  , uint32 * , int  ) ;
extern int TIFFReadRGBAImageOriented(TIFF * , uint32  , uint32  , uint32 * ,
                                     int  , int  ) ;
extern int TIFFReadRGBAStrip(TIFF * , uint32  , uint32 * ) ;
extern int TIFFReadRGBATile(TIFF * , uint32  , uint32  , uint32 * ) ;
extern int TIFFRGBAImageOK(TIFF * , char * ) ;
extern int TIFFRGBAImageBegin(TIFFRGBAImage * , TIFF * , int  , char * ) ;
extern int TIFFRGBAImageGet(TIFFRGBAImage * , uint32 * , uint32  , uint32  ) ;
extern void TIFFRGBAImageEnd(TIFFRGBAImage * ) ;
extern TIFF *TIFFOpen(char const   * , char const   * ) ;
extern TIFF *TIFFFdOpen(int  , char const   * , char const   * ) ;
extern TIFF *TIFFClientOpen(char const   * , char const   * , thandle_t  ,
                            tmsize_t (*)(thandle_t  , void * , tmsize_t  ) ,
                            tmsize_t (*)(thandle_t  , void * , tmsize_t  ) ,
                            uint64 (*)(thandle_t  , uint64  , int  ) ,
                            int (*)(thandle_t  ) , uint64 (*)(thandle_t  ) ,
                            int (*)(thandle_t  , void **base , tmsize_t *size ) ,
                            void (*)(thandle_t  , void *base , tmsize_t size ) ) ;
extern char const   *TIFFFileName(TIFF * ) ;
extern char const   *TIFFSetFileName(TIFF * , char const   * ) ;
extern void TIFFError(char const   * , char const   *  , ...) ;
extern void TIFFErrorExt(thandle_t  , char const   * , char const   *  , ...) ;
extern void TIFFWarning(char const   * , char const   *  , ...) ;
extern void TIFFWarningExt(thandle_t  , char const   * , char const   *  , ...) ;
extern TIFFErrorHandler TIFFSetErrorHandler(void (*)(char const   * ,
                                                     char const   * , va_list  ) ) ;
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(void (*)(thandle_t  ,
                                                           char const   * ,
                                                           char const   * ,
                                                           va_list  ) ) ;
extern TIFFErrorHandler TIFFSetWarningHandler(void (*)(char const   * ,
                                                       char const   * ,
                                                       va_list  ) ) ;
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(void (*)(thandle_t  ,
                                                             char const   * ,
                                                             char const   * ,
                                                             va_list  ) ) ;
extern TIFFExtendProc TIFFSetTagExtender(void (*)(TIFF * ) ) ;
extern uint32 TIFFComputeTile(TIFF *tif , uint32 x , uint32 y , uint32 z ,
                              uint16 s ) ;
extern int TIFFCheckTile(TIFF *tif , uint32 x , uint32 y , uint32 z , uint16 s ) ;
extern uint32 TIFFNumberOfTiles(TIFF * ) ;
extern tmsize_t TIFFReadTile(TIFF *tif , void *buf , uint32 x , uint32 y ,
                             uint32 z , uint16 s ) ;
extern tmsize_t TIFFWriteTile(TIFF *tif , void *buf , uint32 x , uint32 y ,
                              uint32 z , uint16 s ) ;
extern uint32 TIFFComputeStrip(TIFF * , uint32  , uint16  ) ;
extern uint32 TIFFNumberOfStrips(TIFF * ) ;
extern tmsize_t TIFFReadEncodedStrip(TIFF *tif , uint32 strip , void *buf ,
                                     tmsize_t size ) ;
extern tmsize_t TIFFReadRawStrip(TIFF *tif , uint32 strip , void *buf ,
                                 tmsize_t size ) ;
extern tmsize_t TIFFReadEncodedTile(TIFF *tif , uint32 tile , void *buf ,
                                    tmsize_t size ) ;
extern tmsize_t TIFFReadRawTile(TIFF *tif , uint32 tile , void *buf ,
                                tmsize_t size ) ;
extern tmsize_t TIFFWriteEncodedStrip(TIFF *tif , uint32 strip , void *data ,
                                      tmsize_t cc ) ;
extern tmsize_t TIFFWriteRawStrip(TIFF *tif , uint32 strip , void *data ,
                                  tmsize_t cc ) ;
extern tmsize_t TIFFWriteEncodedTile(TIFF *tif , uint32 tile , void *data ,
                                     tmsize_t cc ) ;
extern tmsize_t TIFFWriteRawTile(TIFF *tif , uint32 tile , void *data ,
                                 tmsize_t cc ) ;
extern int TIFFDataWidth(TIFFDataType  ) ;
extern void TIFFSetWriteOffset(TIFF *tif , uint64 off ) ;
extern void TIFFSwabShort(uint16 * ) ;
extern void TIFFSwabLong(uint32 * ) ;
extern void TIFFSwabLong8(uint64 * ) ;
extern void TIFFSwabFloat(float * ) ;
extern void TIFFSwabDouble(double * ) ;
extern void TIFFSwabArrayOfShort(uint16 *wp , tmsize_t n ) ;
extern void TIFFSwabArrayOfTriples(uint8 *tp , tmsize_t n ) ;
extern void TIFFSwabArrayOfLong(uint32 *lp , tmsize_t n ) ;
extern void TIFFSwabArrayOfLong8(uint64 *lp , tmsize_t n ) ;
extern void TIFFSwabArrayOfFloat(float *fp , tmsize_t n ) ;
extern void TIFFSwabArrayOfDouble(double *dp , tmsize_t n ) ;
extern void TIFFReverseBits(uint8 *cp , tmsize_t n ) ;
extern unsigned char const   *TIFFGetBitRevTable(int  ) ;
double LogL16toY(int p16 ) ;
double LogL10toY(int p10 ) ;
void XYZtoRGB24(float *xyz , uint8 *rgb ) ;
int uv_decode(double *up , double *vp , int c ) ;
void LogLuv24toXYZ(uint32 p , float *XYZ ) ;
void LogLuv32toXYZ(uint32 p , float *XYZ ) ;
int LogL16fromY(double Y , int em ) ;
int LogL10fromY(double Y , int em ) ;
int uv_encode(double u , double v , int em ) ;
uint32 LogLuv24fromXYZ(float *XYZ , int em ) ;
uint32 LogLuv32fromXYZ(float *XYZ , int em ) ;
extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB * , TIFFDisplay * , float * ) ;
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB * , uint32  , int32  , int32  ,
                            float * , float * , float * ) ;
extern void TIFFXYZToRGB(TIFFCIELabToRGB * , float  , float  , float  ,
                         uint32 * , uint32 * , uint32 * ) ;
extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB * , float * , float * ) ;
extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB * , uint32  , int32  , int32  ,
                           uint32 * , uint32 * , uint32 * ) ;
extern TIFFFieldInfoArray const   *_TIFFGetFieldInfo(void) ;
extern TIFFFieldInfoArray const   *_TIFFGetExifFieldInfo(void) ;
extern void _TIFFSetupFieldInfo(TIFF *tif ,
                                TIFFFieldInfoArray const   *infoarray ) ;
extern int _TIFFMergeFieldInfo(TIFF * , TIFFFieldInfo const   * , uint32  ) ;
extern void _TIFFPrintFieldInfo(TIFF * , FILE * ) ;
extern int _TIFFMergeField(TIFF * , TIFFField const   * , uint32  ) ;
extern TIFFField const   *_TIFFFindOrRegisterFieldInfo(TIFF * , uint32  ,
                                                       TIFFDataType  ) ;
extern TIFFField *_TIFFCreateAnonField(TIFF * , uint32  , TIFFDataType  ) ;
extern int _TIFFgetMode(char const   *mode , char const   *module ) ;
extern int _TIFFNoRowEncode(TIFF *tif , uint8 *pp , tmsize_t cc , uint16 s ) ;
extern int _TIFFNoStripEncode(TIFF *tif , uint8 *pp , tmsize_t cc , uint16 s ) ;
extern int _TIFFNoTileEncode(TIFF * , uint8 *pp , tmsize_t cc , uint16 s ) ;
extern int _TIFFNoRowDecode(TIFF *tif , uint8 *pp , tmsize_t cc , uint16 s ) ;
extern int _TIFFNoStripDecode(TIFF *tif , uint8 *pp , tmsize_t cc , uint16 s ) ;
extern int _TIFFNoTileDecode(TIFF * , uint8 *pp , tmsize_t cc , uint16 s ) ;
extern void _TIFFNoPostDecode(TIFF *tif , uint8 *buf , tmsize_t cc ) ;
extern int _TIFFNoPreCode(TIFF *tif , uint16 s ) ;
extern int _TIFFNoSeek(TIFF *tif , uint32 off ) ;
extern void _TIFFSwab16BitData(TIFF *tif , uint8 *buf , tmsize_t cc ) ;
extern void _TIFFSwab24BitData(TIFF *tif , uint8 *buf , tmsize_t cc ) ;
extern void _TIFFSwab32BitData(TIFF *tif , uint8 *buf , tmsize_t cc ) ;
extern void _TIFFSwab64BitData(TIFF *tif , uint8 *buf , tmsize_t cc ) ;
extern int TIFFFlushData1(TIFF *tif ) ;
extern int TIFFDefaultDirectory(TIFF *tif ) ;
extern void _TIFFSetDefaultCompressionState(TIFF *tif ) ;
extern int TIFFSetCompressionScheme(TIFF *tif , int scheme ) ;
extern int TIFFSetDefaultCompressionState(TIFF *tif ) ;
extern uint32 _TIFFDefaultStripSize(TIFF *tif , uint32 s ) ;
extern void _TIFFDefaultTileSize(TIFF *tif , uint32 *tw , uint32 *th ) ;
extern int _TIFFDataSize(TIFFDataType type ) ;
extern void _TIFFsetByteArray(void ** , void * , uint32  ) ;
extern void _TIFFsetString(char ** , char * ) ;
extern void _TIFFsetShortArray(uint16 ** , uint16 * , uint32  ) ;
extern void _TIFFsetLongArray(uint32 ** , uint32 * , uint32  ) ;
extern void _TIFFsetFloatArray(float ** , float * , uint32  ) ;
extern void _TIFFsetDoubleArray(double ** , double * , uint32  ) ;
extern void _TIFFprintAscii(FILE * , char const   * ) ;
extern void _TIFFprintAsciiTag(FILE * , char const   * , char const   * ) ;
extern void (*_TIFFwarningHandler)(char const   * , char const   * , va_list  ) ;
extern void (*_TIFFerrorHandler)(char const   * , char const   * , va_list  ) ;
extern void (*_TIFFwarningHandlerExt)(thandle_t  , char const   * ,
                                      char const   * , va_list  ) ;
extern void (*_TIFFerrorHandlerExt)(thandle_t  , char const   * ,
                                    char const   * , va_list  ) ;
extern void *_TIFFCheckMalloc(TIFF *tif , tmsize_t nmemb , tmsize_t elem_size ,
                              char const   *what ) ;
extern void *_TIFFCheckRealloc(TIFF *tif , void *buffer , tmsize_t nmemb ,
                               tmsize_t elem_size , char const   *what ) ;
extern int TIFFInitDumpMode(TIFF * , int  ) ;
extern int TIFFInitPackBits(TIFF * , int  ) ;
extern int TIFFInitCCITTRLE(TIFF * , int  ) ;
extern int TIFFInitCCITTRLEW(TIFF * , int  ) ;
extern int TIFFInitCCITTFax3(TIFF * , int  ) ;
extern int TIFFInitCCITTFax4(TIFF * , int  ) ;
extern int TIFFInitThunderScan(TIFF * , int  ) ;
extern int TIFFInitNeXT(TIFF * , int  ) ;
extern int TIFFInitLZW(TIFF * , int  ) ;
extern int TIFFInitZIP(TIFF * , int  ) ;
extern int TIFFInitPixarLog(TIFF * , int  ) ;
int TIFFInitSGILog(TIFF *tif , int scheme ) ;
extern TIFFCodec _TIFFBuiltinCODECS[] ;
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))) ;
__inline extern  __attribute__((__nothrow__)) double atof(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern double atof(char const   *__nptr ) 
{ double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10208\n");
  fflush(_coverage_fout);
  }
  tmp = strtod((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)));
  {
  fprintf(_coverage_fout, "10209\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) int atoi(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern int atoi(char const   *__nptr ) 
{ long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10210\n");
  fflush(_coverage_fout);
  }
  tmp = strtol((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  fprintf(_coverage_fout, "10211\n");
  fflush(_coverage_fout);
  }
  return ((int )tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long atol(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern long atol(char const   *__nptr ) 
{ long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10212\n");
  fflush(_coverage_fout);
  }
  tmp = strtol((char const   */* __restrict  */)__nptr,
               (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  fprintf(_coverage_fout, "10213\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long long atoll(char const   *__nptr )  __attribute__((__pure__,
__nonnull__(1))) ;
__inline extern long long atoll(char const   *__nptr ) 
{ long long tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10214\n");
  fflush(_coverage_fout);
  }
  tmp = strtoll((char const   */* __restrict  */)__nptr,
                (char **/* __restrict  */)((char **)((void *)0)), 10);
  {
  fprintf(_coverage_fout, "10215\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
extern  __attribute__((__nothrow__)) char *l64a(long __n ) ;
extern  __attribute__((__nothrow__)) long a64l(char const   *__s )  __attribute__((__pure__,
__nonnull__(1))) ;
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 *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 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 _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 )  __asm__("mkstemp64") __attribute__((__nonnull__(1))) ;
extern int mkstemps(char *__template , int __suffixlen )  __asm__("mkstemps64") __attribute__((__nonnull__(1))) ;
extern  __attribute__((__nothrow__)) char *mkdtemp(char *__template )  __attribute__((__nonnull__(1))) ;
extern int system(char const   *__command ) ;
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  __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__)) int getloadavg(double *__loadavg ,
                                                    int __nelem )  __attribute__((__nonnull__(1))) ;
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__)) 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 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__)) 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 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__)) 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 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_47 __u ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10216\n");
  fflush(_coverage_fout);
  }
  __u.__f = __x;
  {
  fprintf(_coverage_fout, "10217\n");
  fflush(_coverage_fout);
  }
  return (__u.__i < 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbit(double __x )  __attribute__((__const__)) ;
__inline extern int __signbit(double __x ) 
{ union __anonunion___u_48 __u ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10218\n");
  fflush(_coverage_fout);
  }
  __u.__d = __x;
  {
  fprintf(_coverage_fout, "10219\n");
  fflush(_coverage_fout);
  }
  return (__u.__i[1] < 0);
}
}
__inline extern  __attribute__((__nothrow__)) int __signbitl(long double __x )  __attribute__((__const__)) ;
__inline extern int __signbitl(long double __x ) 
{ union __anonunion___u_49 __u ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10220\n");
  fflush(_coverage_fout);
  }
  __u.__l = __x;
  {
  fprintf(_coverage_fout, "10221\n");
  fflush(_coverage_fout);
  }
  return ((__u.__i[2] & 0x8000) != 0);
}
}
__inline extern  __attribute__((__nothrow__)) double __sgn(double __x ) ;
__inline extern  __attribute__((__nothrow__)) double __sgn(double __x ) ;
__inline extern double __sgn(double __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10227\n");
  fflush(_coverage_fout);
  }
  if (__x == 0.0) {
    {
    fprintf(_coverage_fout, "10222\n");
    fflush(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    fprintf(_coverage_fout, "10225\n");
    fflush(_coverage_fout);
    }
    if (__x > 0.0) {
      {
      fprintf(_coverage_fout, "10223\n");
      fflush(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      fprintf(_coverage_fout, "10224\n");
      fflush(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    fprintf(_coverage_fout, "10226\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  fprintf(_coverage_fout, "10228\n");
  fflush(_coverage_fout);
  }
  return (tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) float __sgnf(float __x ) ;
__inline extern  __attribute__((__nothrow__)) float __sgnf(float __x ) ;
__inline extern float __sgnf(float __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10234\n");
  fflush(_coverage_fout);
  }
  if ((double )__x == 0.0) {
    {
    fprintf(_coverage_fout, "10229\n");
    fflush(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    fprintf(_coverage_fout, "10232\n");
    fflush(_coverage_fout);
    }
    if ((double )__x > 0.0) {
      {
      fprintf(_coverage_fout, "10230\n");
      fflush(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      fprintf(_coverage_fout, "10231\n");
      fflush(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    fprintf(_coverage_fout, "10233\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  fprintf(_coverage_fout, "10235\n");
  fflush(_coverage_fout);
  }
  return ((float )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) long double __sgnl(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double __sgnl(long double __x ) ;
__inline extern long double __sgnl(long double __x ) 
{ double tmp ;
  double tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10241\n");
  fflush(_coverage_fout);
  }
  if (__x == (long double )0.0) {
    {
    fprintf(_coverage_fout, "10236\n");
    fflush(_coverage_fout);
    }
    tmp___0 = 0.0;
  } else {
    {
    fprintf(_coverage_fout, "10239\n");
    fflush(_coverage_fout);
    }
    if (__x > (long double )0.0) {
      {
      fprintf(_coverage_fout, "10237\n");
      fflush(_coverage_fout);
      }
      tmp = 1.0;
    } else {
      {
      fprintf(_coverage_fout, "10238\n");
      fflush(_coverage_fout);
      }
      tmp = - 1.0;
    }
    {
    fprintf(_coverage_fout, "10240\n");
    fflush(_coverage_fout);
    }
    tmp___0 = tmp;
  }
  {
  fprintf(_coverage_fout, "10242\n");
  fflush(_coverage_fout);
  }
  return ((long double )tmp___0);
}
}
__inline extern  __attribute__((__nothrow__)) long double __atan2l(long double __y ,
                                                                   long double __x ) ;
__inline extern long double __atan2l(long double __y , long double __x ) 
{ long double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10243\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_atan2l(__y, __x);
  {
  fprintf(_coverage_fout, "10244\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) double fabs(double __x )  __attribute__((__const__)) ;
__inline extern double fabs(double __x ) 
{ double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10245\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabs(__x);
  {
  fprintf(_coverage_fout, "10246\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) float fabsf(float __x )  __attribute__((__const__)) ;
__inline extern float fabsf(float __x ) 
{ float tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10247\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabsf(__x);
  {
  fprintf(_coverage_fout, "10248\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern long double fabsl(long double __x ) 
{ long double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10249\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  fprintf(_coverage_fout, "10250\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double __fabsl(long double __x )  __attribute__((__const__)) ;
__inline extern long double __fabsl(long double __x ) 
{ long double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10251\n");
  fflush(_coverage_fout);
  }
  tmp = __builtin_fabsl(__x);
  {
  fprintf(_coverage_fout, "10252\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
__inline extern  __attribute__((__nothrow__)) long double __sgn1l(long double __x ) ;
__inline extern  __attribute__((__nothrow__)) long double __sgn1l(long double __x ) ;
__inline extern long double __sgn1l(long double __x ) 
{ union __anonunion___n_50 __n ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10253\n");
  fflush(_coverage_fout);
  }
  __n.__xld = __x;
  {
  fprintf(_coverage_fout, "10254\n");
  fflush(_coverage_fout);
  }
  __n.__xi[2] = (__n.__xi[2] & 32768U) | 16383U;
  {
  fprintf(_coverage_fout, "10255\n");
  fflush(_coverage_fout);
  }
  __n.__xi[1] = 0x80000000;
  {
  fprintf(_coverage_fout, "10256\n");
  fflush(_coverage_fout);
  }
  __n.__xi[0] = 0U;
  {
  fprintf(_coverage_fout, "10257\n");
  fflush(_coverage_fout);
  }
  return (__n.__xld);
}
}
__inline extern  __attribute__((__nothrow__)) double floor(double __x )  __attribute__((__const__)) ;
__inline extern double floor(double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10258\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0400, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "10259\n");
  fflush(_coverage_fout);
  }
  return ((double )__value);
}
}
__inline extern  __attribute__((__nothrow__)) float floorf(float __x )  __attribute__((__const__)) ;
__inline extern float floorf(float __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10260\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0400, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "10261\n");
  fflush(_coverage_fout);
  }
  return ((float )__value);
}
}
__inline extern  __attribute__((__nothrow__)) long double floorl(long double __x )  __attribute__((__const__)) ;
__inline extern long double floorl(long double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10262\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0400, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "10263\n");
  fflush(_coverage_fout);
  }
  return (__value);
}
}
__inline extern  __attribute__((__nothrow__)) double ceil(double __x )  __attribute__((__const__)) ;
__inline extern double ceil(double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10264\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0800, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "10265\n");
  fflush(_coverage_fout);
  }
  return ((double )__value);
}
}
__inline extern  __attribute__((__nothrow__)) float ceilf(float __x )  __attribute__((__const__)) ;
__inline extern float ceilf(float __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10266\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0800, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "10267\n");
  fflush(_coverage_fout);
  }
  return ((float )__value);
}
}
__inline extern  __attribute__((__nothrow__)) long double ceill(long double __x )  __attribute__((__const__)) ;
__inline extern long double ceill(long double __x ) 
{ register long double __value ;
  register int __ignore ;
  unsigned short __cw ;
  unsigned short __cwtmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10268\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fnstcw %3\n\t"
                       "movzwl %3, %1\n\t"
                       "andl $0xf3ff, %1\n\t"
                       "orl $0x0800, %1\n\t"
                       "movw %w1, %2\n\t"
                       "fldcw %2\n\t"
                       "frndint\n\t"
                       "fldcw %3": "=t" (__value), "=&q" (__ignore),
                       "=m" (__cwtmp), "=m" (__cw): "0" (__x));
  {
  fprintf(_coverage_fout, "10269\n");
  fflush(_coverage_fout);
  }
  return (__value);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintf(float __x ) ;
__inline extern long lrintf(float __x ) 
{ long __lrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10270\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "10271\n");
  fflush(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrint(double __x ) ;
__inline extern long lrint(double __x ) 
{ long __lrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10272\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "10273\n");
  fflush(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long lrintl(long double __x ) ;
__inline extern long lrintl(long double __x ) 
{ long __lrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10274\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpl %0": "=m" (__lrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "10275\n");
  fflush(_coverage_fout);
  }
  return (__lrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintf(float __x ) ;
__inline extern long long llrintf(float __x ) 
{ long long __llrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10276\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "10277\n");
  fflush(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrint(double __x ) ;
__inline extern long long llrint(double __x ) 
{ long long __llrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10278\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "10279\n");
  fflush(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) long long llrintl(long double __x ) ;
__inline extern long long llrintl(long double __x ) 
{ long long __llrintres ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10280\n");
  fflush(_coverage_fout);
  }
  __asm__  volatile   ("fistpll %0": "=m" (__llrintres): "t" (__x): "st");
  {
  fprintf(_coverage_fout, "10281\n");
  fflush(_coverage_fout);
  }
  return (__llrintres);
}
}
__inline extern  __attribute__((__nothrow__)) int __finite(double __x )  __attribute__((__const__)) ;
__inline extern int __finite(double __x ) 
{ union __anonunion_51 __constr_expr_0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10282\n");
  fflush(_coverage_fout);
  }
  __constr_expr_0.__d = __x;
  {
  fprintf(_coverage_fout, "10283\n");
  fflush(_coverage_fout);
  }
  return ((int )((((unsigned int )__constr_expr_0.__i[1] | 0x800fffffu) + 1U) >> 31));
}
}
static int LogL16Decode(TIFF *tif , uint8 *op , tmsize_t occ , uint16 s ) ;
static char const   module[13]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'1',      (char const   )'6',      (char const   )'D',      (char const   )'e', 
        (char const   )'c',      (char const   )'o',      (char const   )'d',      (char const   )'e', 
        (char const   )'\000'};
static int LogL16Decode(TIFF *tif , uint8 *op , tmsize_t occ , uint16 s ) 
{ LogLuvState *sp ;
  int shft ;
  tmsize_t i ;
  tmsize_t npixels ;
  unsigned char *bp ;
  int16 *tp ;
  int16 b ;
  tmsize_t cc ;
  int rc ;
  unsigned char *tmp ;
  unsigned char *tmp___0 ;
  tmsize_t tmp___1 ;
  int tmp___2 ;
  unsigned char *tmp___3 ;
  tmsize_t tmp___4 ;
  unsigned char *tmp___5 ;
  int tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10340\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "10341\n");
  fflush(_coverage_fout);
  }
  if ((int )s == 0) {
    {
    fprintf(_coverage_fout, "10284\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10285\n");
    fflush(_coverage_fout);
    }
    __assert_fail("s == 0", "tif_luv.c", 197U, "LogL16Decode");
  }
  {
  fprintf(_coverage_fout, "10342\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10286\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10287\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 198U, "LogL16Decode");
  }
  {
  fprintf(_coverage_fout, "10343\n");
  fflush(_coverage_fout);
  }
  npixels = occ / (tmsize_t )sp->pixel_size;
  {
  fprintf(_coverage_fout, "10344\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == 1) {
    {
    fprintf(_coverage_fout, "10288\n");
    fflush(_coverage_fout);
    }
    tp = (int16 *)op;
  } else {
    {
    fprintf(_coverage_fout, "10291\n");
    fflush(_coverage_fout);
    }
    if (sp->tbuflen >= npixels) {
      {
      fprintf(_coverage_fout, "10289\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "10290\n");
      fflush(_coverage_fout);
      }
      __assert_fail("sp->tbuflen >= npixels", "tif_luv.c", 205U, "LogL16Decode");
    }
    {
    fprintf(_coverage_fout, "10292\n");
    fflush(_coverage_fout);
    }
    tp = (int16 *)sp->tbuf;
  }
  {
  fprintf(_coverage_fout, "10345\n");
  fflush(_coverage_fout);
  }
  _TIFFmemset((void *)tp, 0,
              (long )((unsigned long )npixels * (unsigned long )sizeof(*(tp + 0))));
  {
  fprintf(_coverage_fout, "10346\n");
  fflush(_coverage_fout);
  }
  bp = tif->tif_rawcp;
  {
  fprintf(_coverage_fout, "10347\n");
  fflush(_coverage_fout);
  }
  cc = tif->tif_rawcc;
  {
  fprintf(_coverage_fout, "10348\n");
  fflush(_coverage_fout);
  }
  shft = 16;
  {
  fprintf(_coverage_fout, "10349\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10335\n");
    fflush(_coverage_fout);
    }
    shft -= 8;
    {
    fprintf(_coverage_fout, "10336\n");
    fflush(_coverage_fout);
    }
    if (shft >= 0) {
      {
      fprintf(_coverage_fout, "10293\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10337\n");
    fflush(_coverage_fout);
    }
    i = 0L;
    {
    fprintf(_coverage_fout, "10338\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10328\n");
      fflush(_coverage_fout);
      }
      if (i < npixels) {
        {
        fprintf(_coverage_fout, "10295\n");
        fflush(_coverage_fout);
        }
        if (cc > 0L) {
          {
          fprintf(_coverage_fout, "10294\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10329\n");
      fflush(_coverage_fout);
      }
      if ((int )*bp >= 128) {
        {
        fprintf(_coverage_fout, "10304\n");
        fflush(_coverage_fout);
        }
        tmp = bp;
        {
        fprintf(_coverage_fout, "10305\n");
        fflush(_coverage_fout);
        }
        bp ++;
        {
        fprintf(_coverage_fout, "10306\n");
        fflush(_coverage_fout);
        }
        rc = (int )*tmp + -126;
        {
        fprintf(_coverage_fout, "10307\n");
        fflush(_coverage_fout);
        }
        tmp___0 = bp;
        {
        fprintf(_coverage_fout, "10308\n");
        fflush(_coverage_fout);
        }
        bp ++;
        {
        fprintf(_coverage_fout, "10309\n");
        fflush(_coverage_fout);
        }
        b = (short )((int )*tmp___0 << shft);
        {
        fprintf(_coverage_fout, "10310\n");
        fflush(_coverage_fout);
        }
        cc -= 2L;
        {
        fprintf(_coverage_fout, "10311\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10298\n");
          fflush(_coverage_fout);
          }
          tmp___2 = rc;
          {
          fprintf(_coverage_fout, "10299\n");
          fflush(_coverage_fout);
          }
          rc --;
          {
          fprintf(_coverage_fout, "10300\n");
          fflush(_coverage_fout);
          }
          if (tmp___2) {
            {
            fprintf(_coverage_fout, "10297\n");
            fflush(_coverage_fout);
            }
            if (i < npixels) {
              {
              fprintf(_coverage_fout, "10296\n");
              fflush(_coverage_fout);
              }

            } else {
              break;
            }
          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10301\n");
          fflush(_coverage_fout);
          }
          tmp___1 = i;
          {
          fprintf(_coverage_fout, "10302\n");
          fflush(_coverage_fout);
          }
          i ++;
          {
          fprintf(_coverage_fout, "10303\n");
          fflush(_coverage_fout);
          }
          *(tp + tmp___1) = (short )((int )*(tp + tmp___1) | (int )b);
        }
      } else {
        {
        fprintf(_coverage_fout, "10324\n");
        fflush(_coverage_fout);
        }
        tmp___3 = bp;
        {
        fprintf(_coverage_fout, "10325\n");
        fflush(_coverage_fout);
        }
        bp ++;
        {
        fprintf(_coverage_fout, "10326\n");
        fflush(_coverage_fout);
        }
        rc = (int )*tmp___3;
        {
        fprintf(_coverage_fout, "10327\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10317\n");
          fflush(_coverage_fout);
          }
          cc --;
          {
          fprintf(_coverage_fout, "10318\n");
          fflush(_coverage_fout);
          }
          if (cc) {
            {
            fprintf(_coverage_fout, "10314\n");
            fflush(_coverage_fout);
            }
            tmp___6 = rc;
            {
            fprintf(_coverage_fout, "10315\n");
            fflush(_coverage_fout);
            }
            rc --;
            {
            fprintf(_coverage_fout, "10316\n");
            fflush(_coverage_fout);
            }
            if (tmp___6) {
              {
              fprintf(_coverage_fout, "10313\n");
              fflush(_coverage_fout);
              }
              if (i < npixels) {
                {
                fprintf(_coverage_fout, "10312\n");
                fflush(_coverage_fout);
                }

              } else {
                break;
              }
            } else {
              break;
            }
          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10319\n");
          fflush(_coverage_fout);
          }
          tmp___4 = i;
          {
          fprintf(_coverage_fout, "10320\n");
          fflush(_coverage_fout);
          }
          i ++;
          {
          fprintf(_coverage_fout, "10321\n");
          fflush(_coverage_fout);
          }
          tmp___5 = bp;
          {
          fprintf(_coverage_fout, "10322\n");
          fflush(_coverage_fout);
          }
          bp ++;
          {
          fprintf(_coverage_fout, "10323\n");
          fflush(_coverage_fout);
          }
          *(tp + tmp___4) = (short )((int )*(tp + tmp___4) | ((int )((short )*tmp___5) << shft));
        }
      }
    }
    {
    fprintf(_coverage_fout, "10339\n");
    fflush(_coverage_fout);
    }
    if (i != npixels) {
      {
      fprintf(_coverage_fout, "10330\n");
      fflush(_coverage_fout);
      }
      TIFFErrorExt(tif->tif_clientdata, module,
                   "Not enough data at row %lud (short %llud pixels)",
                   (unsigned long )tif->tif_row,
                   (unsigned long long )(npixels - i));
      {
      fprintf(_coverage_fout, "10331\n");
      fflush(_coverage_fout);
      }
      tif->tif_rawcp = bp;
      {
      fprintf(_coverage_fout, "10332\n");
      fflush(_coverage_fout);
      }
      tif->tif_rawcc = cc;
      {
      fprintf(_coverage_fout, "10333\n");
      fflush(_coverage_fout);
      }
      return (0);
    } else {
      {
      fprintf(_coverage_fout, "10334\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "10350\n");
  fflush(_coverage_fout);
  }
  (*(sp->tfunc))(sp, op, npixels);
  {
  fprintf(_coverage_fout, "10351\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcp = bp;
  {
  fprintf(_coverage_fout, "10352\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcc = cc;
  {
  fprintf(_coverage_fout, "10353\n");
  fflush(_coverage_fout);
  }
  return (1);
}
}
static int LogLuvDecode24(TIFF *tif , uint8 *op , tmsize_t occ , uint16 s ) ;
static char const   module___0[15]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'u',      (char const   )'v',      (char const   )'D',      (char const   )'e', 
        (char const   )'c',      (char const   )'o',      (char const   )'d',      (char const   )'e', 
        (char const   )'2',      (char const   )'4',      (char const   )'\000'};
static int LogLuvDecode24(TIFF *tif , uint8 *op , tmsize_t occ , uint16 s ) 
{ LogLuvState *sp ;
  tmsize_t cc ;
  tmsize_t i ;
  tmsize_t npixels ;
  unsigned char *bp ;
  uint32 *tp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10373\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "10374\n");
  fflush(_coverage_fout);
  }
  if ((int )s == 0) {
    {
    fprintf(_coverage_fout, "10354\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10355\n");
    fflush(_coverage_fout);
    }
    __assert_fail("s == 0", "tif_luv.c", 255U, "LogLuvDecode24");
  }
  {
  fprintf(_coverage_fout, "10375\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10356\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10357\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 256U, "LogLuvDecode24");
  }
  {
  fprintf(_coverage_fout, "10376\n");
  fflush(_coverage_fout);
  }
  npixels = occ / (tmsize_t )sp->pixel_size;
  {
  fprintf(_coverage_fout, "10377\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == 2) {
    {
    fprintf(_coverage_fout, "10358\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)op;
  } else {
    {
    fprintf(_coverage_fout, "10361\n");
    fflush(_coverage_fout);
    }
    if (sp->tbuflen >= npixels) {
      {
      fprintf(_coverage_fout, "10359\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "10360\n");
      fflush(_coverage_fout);
      }
      __assert_fail("sp->tbuflen >= npixels", "tif_luv.c", 263U,
                    "LogLuvDecode24");
    }
    {
    fprintf(_coverage_fout, "10362\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)sp->tbuf;
  }
  {
  fprintf(_coverage_fout, "10378\n");
  fflush(_coverage_fout);
  }
  bp = tif->tif_rawcp;
  {
  fprintf(_coverage_fout, "10379\n");
  fflush(_coverage_fout);
  }
  cc = tif->tif_rawcc;
  {
  fprintf(_coverage_fout, "10380\n");
  fflush(_coverage_fout);
  }
  i = 0L;
  {
  fprintf(_coverage_fout, "10381\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10365\n");
    fflush(_coverage_fout);
    }
    if (i < npixels) {
      {
      fprintf(_coverage_fout, "10364\n");
      fflush(_coverage_fout);
      }
      if (cc > 0L) {
        {
        fprintf(_coverage_fout, "10363\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10366\n");
    fflush(_coverage_fout);
    }
    *(tp + i) = (unsigned int )((((int )*(bp + 0) << 16) | ((int )*(bp + 1) << 8)) | (int )*(bp + 2));
    {
    fprintf(_coverage_fout, "10367\n");
    fflush(_coverage_fout);
    }
    bp += 3;
    {
    fprintf(_coverage_fout, "10368\n");
    fflush(_coverage_fout);
    }
    cc -= 3L;
    {
    fprintf(_coverage_fout, "10369\n");
    fflush(_coverage_fout);
    }
    i ++;
  }
  {
  fprintf(_coverage_fout, "10382\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcp = bp;
  {
  fprintf(_coverage_fout, "10383\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcc = cc;
  {
  fprintf(_coverage_fout, "10384\n");
  fflush(_coverage_fout);
  }
  if (i != npixels) {
    {
    fprintf(_coverage_fout, "10370\n");
    fflush(_coverage_fout);
    }
    TIFFErrorExt(tif->tif_clientdata, module___0,
                 "Not enough data at row %lud (short %llud pixels)",
                 (unsigned long )tif->tif_row,
                 (unsigned long long )(npixels - i));
    {
    fprintf(_coverage_fout, "10371\n");
    fflush(_coverage_fout);
    }
    return (0);
  } else {
    {
    fprintf(_coverage_fout, "10372\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10385\n");
  fflush(_coverage_fout);
  }
  (*(sp->tfunc))(sp, op, npixels);
  {
  fprintf(_coverage_fout, "10386\n");
  fflush(_coverage_fout);
  }
  return (1);
}
}
static int LogLuvDecode32(TIFF *tif , uint8 *op , tmsize_t occ , uint16 s ) ;
static char const   module___1[15]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'u',      (char const   )'v',      (char const   )'D',      (char const   )'e', 
        (char const   )'c',      (char const   )'o',      (char const   )'d',      (char const   )'e', 
        (char const   )'3',      (char const   )'2',      (char const   )'\000'};
static int LogLuvDecode32(TIFF *tif , uint8 *op , tmsize_t occ , uint16 s ) 
{ LogLuvState *sp ;
  int shft ;
  tmsize_t i ;
  tmsize_t npixels ;
  unsigned char *bp ;
  uint32 *tp ;
  uint32 b ;
  tmsize_t cc ;
  int rc ;
  unsigned char *tmp ;
  unsigned char *tmp___0 ;
  tmsize_t tmp___1 ;
  int tmp___2 ;
  unsigned char *tmp___3 ;
  tmsize_t tmp___4 ;
  unsigned char *tmp___5 ;
  int tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10443\n");
  fflush(_coverage_fout);
  }
  if ((int )s == 0) {
    {
    fprintf(_coverage_fout, "10387\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10388\n");
    fflush(_coverage_fout);
    }
    __assert_fail("s == 0", "tif_luv.c", 303U, "LogLuvDecode32");
  }
  {
  fprintf(_coverage_fout, "10444\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "10445\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10389\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10390\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 305U, "LogLuvDecode32");
  }
  {
  fprintf(_coverage_fout, "10446\n");
  fflush(_coverage_fout);
  }
  npixels = occ / (tmsize_t )sp->pixel_size;
  {
  fprintf(_coverage_fout, "10447\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == 2) {
    {
    fprintf(_coverage_fout, "10391\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)op;
  } else {
    {
    fprintf(_coverage_fout, "10394\n");
    fflush(_coverage_fout);
    }
    if (sp->tbuflen >= npixels) {
      {
      fprintf(_coverage_fout, "10392\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "10393\n");
      fflush(_coverage_fout);
      }
      __assert_fail("sp->tbuflen >= npixels", "tif_luv.c", 312U,
                    "LogLuvDecode32");
    }
    {
    fprintf(_coverage_fout, "10395\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)sp->tbuf;
  }
  {
  fprintf(_coverage_fout, "10448\n");
  fflush(_coverage_fout);
  }
  _TIFFmemset((void *)tp, 0,
              (long )((unsigned long )npixels * (unsigned long )sizeof(*(tp + 0))));
  {
  fprintf(_coverage_fout, "10449\n");
  fflush(_coverage_fout);
  }
  bp = tif->tif_rawcp;
  {
  fprintf(_coverage_fout, "10450\n");
  fflush(_coverage_fout);
  }
  cc = tif->tif_rawcc;
  {
  fprintf(_coverage_fout, "10451\n");
  fflush(_coverage_fout);
  }
  shft = 32;
  {
  fprintf(_coverage_fout, "10452\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10438\n");
    fflush(_coverage_fout);
    }
    shft -= 8;
    {
    fprintf(_coverage_fout, "10439\n");
    fflush(_coverage_fout);
    }
    if (shft >= 0) {
      {
      fprintf(_coverage_fout, "10396\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10440\n");
    fflush(_coverage_fout);
    }
    i = 0L;
    {
    fprintf(_coverage_fout, "10441\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10431\n");
      fflush(_coverage_fout);
      }
      if (i < npixels) {
        {
        fprintf(_coverage_fout, "10398\n");
        fflush(_coverage_fout);
        }
        if (cc > 0L) {
          {
          fprintf(_coverage_fout, "10397\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10432\n");
      fflush(_coverage_fout);
      }
      if ((int )*bp >= 128) {
        {
        fprintf(_coverage_fout, "10407\n");
        fflush(_coverage_fout);
        }
        tmp = bp;
        {
        fprintf(_coverage_fout, "10408\n");
        fflush(_coverage_fout);
        }
        bp ++;
        {
        fprintf(_coverage_fout, "10409\n");
        fflush(_coverage_fout);
        }
        rc = (int )*tmp + -126;
        {
        fprintf(_coverage_fout, "10410\n");
        fflush(_coverage_fout);
        }
        tmp___0 = bp;
        {
        fprintf(_coverage_fout, "10411\n");
        fflush(_coverage_fout);
        }
        bp ++;
        {
        fprintf(_coverage_fout, "10412\n");
        fflush(_coverage_fout);
        }
        b = (unsigned int )*tmp___0 << shft;
        {
        fprintf(_coverage_fout, "10413\n");
        fflush(_coverage_fout);
        }
        cc -= 2L;
        {
        fprintf(_coverage_fout, "10414\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10401\n");
          fflush(_coverage_fout);
          }
          tmp___2 = rc;
          {
          fprintf(_coverage_fout, "10402\n");
          fflush(_coverage_fout);
          }
          rc --;
          {
          fprintf(_coverage_fout, "10403\n");
          fflush(_coverage_fout);
          }
          if (tmp___2) {
            {
            fprintf(_coverage_fout, "10400\n");
            fflush(_coverage_fout);
            }
            if (i < npixels) {
              {
              fprintf(_coverage_fout, "10399\n");
              fflush(_coverage_fout);
              }

            } else {
              break;
            }
          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10404\n");
          fflush(_coverage_fout);
          }
          tmp___1 = i;
          {
          fprintf(_coverage_fout, "10405\n");
          fflush(_coverage_fout);
          }
          i ++;
          {
          fprintf(_coverage_fout, "10406\n");
          fflush(_coverage_fout);
          }
          *(tp + tmp___1) |= b;
        }
      } else {
        {
        fprintf(_coverage_fout, "10427\n");
        fflush(_coverage_fout);
        }
        tmp___3 = bp;
        {
        fprintf(_coverage_fout, "10428\n");
        fflush(_coverage_fout);
        }
        bp ++;
        {
        fprintf(_coverage_fout, "10429\n");
        fflush(_coverage_fout);
        }
        rc = (int )*tmp___3;
        {
        fprintf(_coverage_fout, "10430\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10420\n");
          fflush(_coverage_fout);
          }
          cc --;
          {
          fprintf(_coverage_fout, "10421\n");
          fflush(_coverage_fout);
          }
          if (cc) {
            {
            fprintf(_coverage_fout, "10417\n");
            fflush(_coverage_fout);
            }
            tmp___6 = rc;
            {
            fprintf(_coverage_fout, "10418\n");
            fflush(_coverage_fout);
            }
            rc --;
            {
            fprintf(_coverage_fout, "10419\n");
            fflush(_coverage_fout);
            }
            if (tmp___6) {
              {
              fprintf(_coverage_fout, "10416\n");
              fflush(_coverage_fout);
              }
              if (i < npixels) {
                {
                fprintf(_coverage_fout, "10415\n");
                fflush(_coverage_fout);
                }

              } else {
                break;
              }
            } else {
              break;
            }
          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10422\n");
          fflush(_coverage_fout);
          }
          tmp___4 = i;
          {
          fprintf(_coverage_fout, "10423\n");
          fflush(_coverage_fout);
          }
          i ++;
          {
          fprintf(_coverage_fout, "10424\n");
          fflush(_coverage_fout);
          }
          tmp___5 = bp;
          {
          fprintf(_coverage_fout, "10425\n");
          fflush(_coverage_fout);
          }
          bp ++;
          {
          fprintf(_coverage_fout, "10426\n");
          fflush(_coverage_fout);
          }
          *(tp + tmp___4) |= (unsigned int )*tmp___5 << shft;
        }
      }
    }
    {
    fprintf(_coverage_fout, "10442\n");
    fflush(_coverage_fout);
    }
    if (i != npixels) {
      {
      fprintf(_coverage_fout, "10433\n");
      fflush(_coverage_fout);
      }
      TIFFErrorExt(tif->tif_clientdata, module___1,
                   "Not enough data at row %lud (short %llud pixels)",
                   (unsigned long )tif->tif_row,
                   (unsigned long long )(npixels - i));
      {
      fprintf(_coverage_fout, "10434\n");
      fflush(_coverage_fout);
      }
      tif->tif_rawcp = bp;
      {
      fprintf(_coverage_fout, "10435\n");
      fflush(_coverage_fout);
      }
      tif->tif_rawcc = cc;
      {
      fprintf(_coverage_fout, "10436\n");
      fflush(_coverage_fout);
      }
      return (0);
    } else {
      {
      fprintf(_coverage_fout, "10437\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "10453\n");
  fflush(_coverage_fout);
  }
  (*(sp->tfunc))(sp, op, npixels);
  {
  fprintf(_coverage_fout, "10454\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcp = bp;
  {
  fprintf(_coverage_fout, "10455\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcc = cc;
  {
  fprintf(_coverage_fout, "10456\n");
  fflush(_coverage_fout);
  }
  return (1);
}
}
static int LogLuvDecodeStrip(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ tmsize_t rowlen ;
  tmsize_t tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10465\n");
  fflush(_coverage_fout);
  }
  tmp = TIFFScanlineSize(tif);
  {
  fprintf(_coverage_fout, "10466\n");
  fflush(_coverage_fout);
  }
  rowlen = tmp;
  {
  fprintf(_coverage_fout, "10467\n");
  fflush(_coverage_fout);
  }
  if (cc % rowlen == 0L) {
    {
    fprintf(_coverage_fout, "10457\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10458\n");
    fflush(_coverage_fout);
    }
    __assert_fail("cc%rowlen == 0", "tif_luv.c", 358U, "LogLuvDecodeStrip");
  }
  {
  fprintf(_coverage_fout, "10468\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10462\n");
    fflush(_coverage_fout);
    }
    if (cc) {
      {
      fprintf(_coverage_fout, "10460\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (*(tif->tif_decoderow))(tif, bp, rowlen, s);
      {
      fprintf(_coverage_fout, "10461\n");
      fflush(_coverage_fout);
      }
      if (tmp___0) {
        {
        fprintf(_coverage_fout, "10459\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10463\n");
    fflush(_coverage_fout);
    }
    bp += rowlen;
    {
    fprintf(_coverage_fout, "10464\n");
    fflush(_coverage_fout);
    }
    cc -= rowlen;
  }
  {
  fprintf(_coverage_fout, "10469\n");
  fflush(_coverage_fout);
  }
  return (cc == 0L);
}
}
static int LogLuvDecodeTile(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ tmsize_t rowlen ;
  tmsize_t tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10478\n");
  fflush(_coverage_fout);
  }
  tmp = TIFFTileRowSize(tif);
  {
  fprintf(_coverage_fout, "10479\n");
  fflush(_coverage_fout);
  }
  rowlen = tmp;
  {
  fprintf(_coverage_fout, "10480\n");
  fflush(_coverage_fout);
  }
  if (cc % rowlen == 0L) {
    {
    fprintf(_coverage_fout, "10470\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10471\n");
    fflush(_coverage_fout);
    }
    __assert_fail("cc%rowlen == 0", "tif_luv.c", 374U, "LogLuvDecodeTile");
  }
  {
  fprintf(_coverage_fout, "10481\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10475\n");
    fflush(_coverage_fout);
    }
    if (cc) {
      {
      fprintf(_coverage_fout, "10473\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (*(tif->tif_decoderow))(tif, bp, rowlen, s);
      {
      fprintf(_coverage_fout, "10474\n");
      fflush(_coverage_fout);
      }
      if (tmp___0) {
        {
        fprintf(_coverage_fout, "10472\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10476\n");
    fflush(_coverage_fout);
    }
    bp += rowlen;
    {
    fprintf(_coverage_fout, "10477\n");
    fflush(_coverage_fout);
    }
    cc -= rowlen;
  }
  {
  fprintf(_coverage_fout, "10482\n");
  fflush(_coverage_fout);
  }
  return (cc == 0L);
}
}
static int LogL16Encode(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ LogLuvState *sp ;
  int shft ;
  tmsize_t i ;
  tmsize_t j ;
  tmsize_t npixels ;
  uint8 *op ;
  int16 *tp ;
  int16 b ;
  tmsize_t occ ;
  int rc ;
  int mask ;
  tmsize_t beg ;
  int tmp ;
  uint8 *tmp___0 ;
  uint8 *tmp___1 ;
  tmsize_t tmp___2 ;
  int tmp___3 ;
  uint8 *tmp___4 ;
  uint8 *tmp___5 ;
  tmsize_t tmp___6 ;
  tmsize_t tmp___7 ;
  uint8 *tmp___8 ;
  uint8 *tmp___9 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10589\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "10590\n");
  fflush(_coverage_fout);
  }
  rc = 0;
  {
  fprintf(_coverage_fout, "10591\n");
  fflush(_coverage_fout);
  }
  if ((int )s == 0) {
    {
    fprintf(_coverage_fout, "10483\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10484\n");
    fflush(_coverage_fout);
    }
    __assert_fail("s == 0", "tif_luv.c", 398U, "LogL16Encode");
  }
  {
  fprintf(_coverage_fout, "10592\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10485\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10486\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 399U, "LogL16Encode");
  }
  {
  fprintf(_coverage_fout, "10593\n");
  fflush(_coverage_fout);
  }
  npixels = cc / (tmsize_t )sp->pixel_size;
  {
  fprintf(_coverage_fout, "10594\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == 1) {
    {
    fprintf(_coverage_fout, "10487\n");
    fflush(_coverage_fout);
    }
    tp = (int16 *)bp;
  } else {
    {
    fprintf(_coverage_fout, "10490\n");
    fflush(_coverage_fout);
    }
    tp = (int16 *)sp->tbuf;
    {
    fprintf(_coverage_fout, "10491\n");
    fflush(_coverage_fout);
    }
    if (sp->tbuflen >= npixels) {
      {
      fprintf(_coverage_fout, "10488\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "10489\n");
      fflush(_coverage_fout);
      }
      __assert_fail("sp->tbuflen >= npixels", "tif_luv.c", 406U, "LogL16Encode");
    }
    {
    fprintf(_coverage_fout, "10492\n");
    fflush(_coverage_fout);
    }
    (*(sp->tfunc))(sp, bp, npixels);
  }
  {
  fprintf(_coverage_fout, "10595\n");
  fflush(_coverage_fout);
  }
  op = tif->tif_rawcp;
  {
  fprintf(_coverage_fout, "10596\n");
  fflush(_coverage_fout);
  }
  occ = tif->tif_rawdatasize - tif->tif_rawcc;
  {
  fprintf(_coverage_fout, "10597\n");
  fflush(_coverage_fout);
  }
  shft = 16;
  {
  fprintf(_coverage_fout, "10598\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10585\n");
    fflush(_coverage_fout);
    }
    shft -= 8;
    {
    fprintf(_coverage_fout, "10586\n");
    fflush(_coverage_fout);
    }
    if (shft >= 0) {
      {
      fprintf(_coverage_fout, "10493\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10587\n");
    fflush(_coverage_fout);
    }
    i = 0L;
    {
    fprintf(_coverage_fout, "10588\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10576\n");
      fflush(_coverage_fout);
      }
      if (i < npixels) {
        {
        fprintf(_coverage_fout, "10494\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10577\n");
      fflush(_coverage_fout);
      }
      if (occ < 4L) {
        {
        fprintf(_coverage_fout, "10497\n");
        fflush(_coverage_fout);
        }
        tif->tif_rawcp = op;
        {
        fprintf(_coverage_fout, "10498\n");
        fflush(_coverage_fout);
        }
        tif->tif_rawcc = tif->tif_rawdatasize - occ;
        {
        fprintf(_coverage_fout, "10499\n");
        fflush(_coverage_fout);
        }
        tmp = TIFFFlushData1(tif);
        {
        fprintf(_coverage_fout, "10500\n");
        fflush(_coverage_fout);
        }
        if (tmp) {
          {
          fprintf(_coverage_fout, "10495\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "10496\n");
          fflush(_coverage_fout);
          }
          return (-1);
        }
        {
        fprintf(_coverage_fout, "10501\n");
        fflush(_coverage_fout);
        }
        op = tif->tif_rawcp;
        {
        fprintf(_coverage_fout, "10502\n");
        fflush(_coverage_fout);
        }
        occ = tif->tif_rawdatasize - tif->tif_rawcc;
      } else {
        {
        fprintf(_coverage_fout, "10503\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "10578\n");
      fflush(_coverage_fout);
      }
      mask = 0xff << shft;
      {
      fprintf(_coverage_fout, "10579\n");
      fflush(_coverage_fout);
      }
      beg = i;
      {
      fprintf(_coverage_fout, "10580\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "10511\n");
        fflush(_coverage_fout);
        }
        if (beg < npixels) {
          {
          fprintf(_coverage_fout, "10504\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "10512\n");
        fflush(_coverage_fout);
        }
        b = (short )((int )*(tp + beg) & mask);
        {
        fprintf(_coverage_fout, "10513\n");
        fflush(_coverage_fout);
        }
        rc = 1;
        {
        fprintf(_coverage_fout, "10514\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10508\n");
          fflush(_coverage_fout);
          }
          if (rc < 129) {
            {
            fprintf(_coverage_fout, "10507\n");
            fflush(_coverage_fout);
            }
            if (beg + (tmsize_t )rc < npixels) {
              {
              fprintf(_coverage_fout, "10506\n");
              fflush(_coverage_fout);
              }
              if (((int )*(tp + (beg + (tmsize_t )rc)) & mask) == (int )b) {
                {
                fprintf(_coverage_fout, "10505\n");
                fflush(_coverage_fout);
                }

              } else {
                break;
              }
            } else {
              break;
            }
          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10509\n");
          fflush(_coverage_fout);
          }
          rc ++;
        }
        {
        fprintf(_coverage_fout, "10515\n");
        fflush(_coverage_fout);
        }
        if (rc >= 4) {
          break;
        } else {
          {
          fprintf(_coverage_fout, "10510\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10516\n");
        fflush(_coverage_fout);
        }
        beg += (tmsize_t )rc;
      }
      {
      fprintf(_coverage_fout, "10581\n");
      fflush(_coverage_fout);
      }
      if (beg - i > 1L) {
        {
        fprintf(_coverage_fout, "10535\n");
        fflush(_coverage_fout);
        }
        if (beg - i < 4L) {
          {
          fprintf(_coverage_fout, "10531\n");
          fflush(_coverage_fout);
          }
          b = (short )((int )*(tp + i) & mask);
          {
          fprintf(_coverage_fout, "10532\n");
          fflush(_coverage_fout);
          }
          j = i + 1L;
          {
          fprintf(_coverage_fout, "10533\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "10527\n");
            fflush(_coverage_fout);
            }
            tmp___2 = j;
            {
            fprintf(_coverage_fout, "10528\n");
            fflush(_coverage_fout);
            }
            j ++;
            {
            fprintf(_coverage_fout, "10529\n");
            fflush(_coverage_fout);
            }
            if (((int )*(tp + tmp___2) & mask) == (int )b) {
              {
              fprintf(_coverage_fout, "10517\n");
              fflush(_coverage_fout);
              }

            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "10530\n");
            fflush(_coverage_fout);
            }
            if (j == beg) {
              {
              fprintf(_coverage_fout, "10518\n");
              fflush(_coverage_fout);
              }
              tmp___0 = op;
              {
              fprintf(_coverage_fout, "10519\n");
              fflush(_coverage_fout);
              }
              op ++;
              {
              fprintf(_coverage_fout, "10520\n");
              fflush(_coverage_fout);
              }
              *tmp___0 = (unsigned char )((126L + j) - i);
              {
              fprintf(_coverage_fout, "10521\n");
              fflush(_coverage_fout);
              }
              tmp___1 = op;
              {
              fprintf(_coverage_fout, "10522\n");
              fflush(_coverage_fout);
              }
              op ++;
              {
              fprintf(_coverage_fout, "10523\n");
              fflush(_coverage_fout);
              }
              *tmp___1 = (unsigned char )((int )b >> shft);
              {
              fprintf(_coverage_fout, "10524\n");
              fflush(_coverage_fout);
              }
              occ -= 2L;
              {
              fprintf(_coverage_fout, "10525\n");
              fflush(_coverage_fout);
              }
              i = beg;
              break;
            } else {
              {
              fprintf(_coverage_fout, "10526\n");
              fflush(_coverage_fout);
              }

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

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

      }
      {
      fprintf(_coverage_fout, "10582\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "10559\n");
        fflush(_coverage_fout);
        }
        if (i < beg) {
          {
          fprintf(_coverage_fout, "10537\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "10560\n");
        fflush(_coverage_fout);
        }
        j = beg - i;
        {
        fprintf(_coverage_fout, "10561\n");
        fflush(_coverage_fout);
        }
        if (j > 127L) {
          {
          fprintf(_coverage_fout, "10538\n");
          fflush(_coverage_fout);
          }
          j = 127L;
        } else {
          {
          fprintf(_coverage_fout, "10539\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10562\n");
        fflush(_coverage_fout);
        }
        if (occ < j + 3L) {
          {
          fprintf(_coverage_fout, "10542\n");
          fflush(_coverage_fout);
          }
          tif->tif_rawcp = op;
          {
          fprintf(_coverage_fout, "10543\n");
          fflush(_coverage_fout);
          }
          tif->tif_rawcc = tif->tif_rawdatasize - occ;
          {
          fprintf(_coverage_fout, "10544\n");
          fflush(_coverage_fout);
          }
          tmp___3 = TIFFFlushData1(tif);
          {
          fprintf(_coverage_fout, "10545\n");
          fflush(_coverage_fout);
          }
          if (tmp___3) {
            {
            fprintf(_coverage_fout, "10540\n");
            fflush(_coverage_fout);
            }

          } else {
            {
            fprintf(_coverage_fout, "10541\n");
            fflush(_coverage_fout);
            }
            return (-1);
          }
          {
          fprintf(_coverage_fout, "10546\n");
          fflush(_coverage_fout);
          }
          op = tif->tif_rawcp;
          {
          fprintf(_coverage_fout, "10547\n");
          fflush(_coverage_fout);
          }
          occ = tif->tif_rawdatasize - tif->tif_rawcc;
        } else {
          {
          fprintf(_coverage_fout, "10548\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10563\n");
        fflush(_coverage_fout);
        }
        tmp___4 = op;
        {
        fprintf(_coverage_fout, "10564\n");
        fflush(_coverage_fout);
        }
        op ++;
        {
        fprintf(_coverage_fout, "10565\n");
        fflush(_coverage_fout);
        }
        *tmp___4 = (unsigned char )j;
        {
        fprintf(_coverage_fout, "10566\n");
        fflush(_coverage_fout);
        }
        occ --;
        {
        fprintf(_coverage_fout, "10567\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10550\n");
          fflush(_coverage_fout);
          }
          tmp___7 = j;
          {
          fprintf(_coverage_fout, "10551\n");
          fflush(_coverage_fout);
          }
          j --;
          {
          fprintf(_coverage_fout, "10552\n");
          fflush(_coverage_fout);
          }
          if (tmp___7) {
            {
            fprintf(_coverage_fout, "10549\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10553\n");
          fflush(_coverage_fout);
          }
          tmp___5 = op;
          {
          fprintf(_coverage_fout, "10554\n");
          fflush(_coverage_fout);
          }
          op ++;
          {
          fprintf(_coverage_fout, "10555\n");
          fflush(_coverage_fout);
          }
          tmp___6 = i;
          {
          fprintf(_coverage_fout, "10556\n");
          fflush(_coverage_fout);
          }
          i ++;
          {
          fprintf(_coverage_fout, "10557\n");
          fflush(_coverage_fout);
          }
          *tmp___5 = (unsigned char )(((int )*(tp + tmp___6) >> shft) & 0xff);
          {
          fprintf(_coverage_fout, "10558\n");
          fflush(_coverage_fout);
          }
          occ --;
        }
      }
      {
      fprintf(_coverage_fout, "10583\n");
      fflush(_coverage_fout);
      }
      if (rc >= 4) {
        {
        fprintf(_coverage_fout, "10568\n");
        fflush(_coverage_fout);
        }
        tmp___8 = op;
        {
        fprintf(_coverage_fout, "10569\n");
        fflush(_coverage_fout);
        }
        op ++;
        {
        fprintf(_coverage_fout, "10570\n");
        fflush(_coverage_fout);
        }
        *tmp___8 = (unsigned char )(126 + rc);
        {
        fprintf(_coverage_fout, "10571\n");
        fflush(_coverage_fout);
        }
        tmp___9 = op;
        {
        fprintf(_coverage_fout, "10572\n");
        fflush(_coverage_fout);
        }
        op ++;
        {
        fprintf(_coverage_fout, "10573\n");
        fflush(_coverage_fout);
        }
        *tmp___9 = (unsigned char )(((int )*(tp + beg) >> shft) & 0xff);
        {
        fprintf(_coverage_fout, "10574\n");
        fflush(_coverage_fout);
        }
        occ -= 2L;
      } else {
        {
        fprintf(_coverage_fout, "10575\n");
        fflush(_coverage_fout);
        }
        rc = 0;
      }
      {
      fprintf(_coverage_fout, "10584\n");
      fflush(_coverage_fout);
      }
      i += (tmsize_t )rc;
    }
  }
  {
  fprintf(_coverage_fout, "10599\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcp = op;
  {
  fprintf(_coverage_fout, "10600\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcc = tif->tif_rawdatasize - occ;
  {
  fprintf(_coverage_fout, "10601\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int LogLuvEncode24(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ LogLuvState *sp ;
  tmsize_t i ;
  tmsize_t npixels ;
  tmsize_t occ ;
  uint8 *op ;
  uint32 *tp ;
  int tmp ;
  uint8 *tmp___0 ;
  uint8 *tmp___1 ;
  uint8 *tmp___2 ;
  uint32 *tmp___3 ;
  tmsize_t tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10638\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "10639\n");
  fflush(_coverage_fout);
  }
  if ((int )s == 0) {
    {
    fprintf(_coverage_fout, "10602\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10603\n");
    fflush(_coverage_fout);
    }
    __assert_fail("s == 0", "tif_luv.c", 486U, "LogLuvEncode24");
  }
  {
  fprintf(_coverage_fout, "10640\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10604\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10605\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 487U, "LogLuvEncode24");
  }
  {
  fprintf(_coverage_fout, "10641\n");
  fflush(_coverage_fout);
  }
  npixels = cc / (tmsize_t )sp->pixel_size;
  {
  fprintf(_coverage_fout, "10642\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == 2) {
    {
    fprintf(_coverage_fout, "10606\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)bp;
  } else {
    {
    fprintf(_coverage_fout, "10609\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)sp->tbuf;
    {
    fprintf(_coverage_fout, "10610\n");
    fflush(_coverage_fout);
    }
    if (sp->tbuflen >= npixels) {
      {
      fprintf(_coverage_fout, "10607\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "10608\n");
      fflush(_coverage_fout);
      }
      __assert_fail("sp->tbuflen >= npixels", "tif_luv.c", 494U,
                    "LogLuvEncode24");
    }
    {
    fprintf(_coverage_fout, "10611\n");
    fflush(_coverage_fout);
    }
    (*(sp->tfunc))(sp, bp, npixels);
  }
  {
  fprintf(_coverage_fout, "10643\n");
  fflush(_coverage_fout);
  }
  op = tif->tif_rawcp;
  {
  fprintf(_coverage_fout, "10644\n");
  fflush(_coverage_fout);
  }
  occ = tif->tif_rawdatasize - tif->tif_rawcc;
  {
  fprintf(_coverage_fout, "10645\n");
  fflush(_coverage_fout);
  }
  i = npixels;
  {
  fprintf(_coverage_fout, "10646\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10622\n");
    fflush(_coverage_fout);
    }
    tmp___4 = i;
    {
    fprintf(_coverage_fout, "10623\n");
    fflush(_coverage_fout);
    }
    i --;
    {
    fprintf(_coverage_fout, "10624\n");
    fflush(_coverage_fout);
    }
    if (tmp___4) {
      {
      fprintf(_coverage_fout, "10612\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10625\n");
    fflush(_coverage_fout);
    }
    if (occ < 3L) {
      {
      fprintf(_coverage_fout, "10615\n");
      fflush(_coverage_fout);
      }
      tif->tif_rawcp = op;
      {
      fprintf(_coverage_fout, "10616\n");
      fflush(_coverage_fout);
      }
      tif->tif_rawcc = tif->tif_rawdatasize - occ;
      {
      fprintf(_coverage_fout, "10617\n");
      fflush(_coverage_fout);
      }
      tmp = TIFFFlushData1(tif);
      {
      fprintf(_coverage_fout, "10618\n");
      fflush(_coverage_fout);
      }
      if (tmp) {
        {
        fprintf(_coverage_fout, "10613\n");
        fflush(_coverage_fout);
        }

      } else {
        {
        fprintf(_coverage_fout, "10614\n");
        fflush(_coverage_fout);
        }
        return (-1);
      }
      {
      fprintf(_coverage_fout, "10619\n");
      fflush(_coverage_fout);
      }
      op = tif->tif_rawcp;
      {
      fprintf(_coverage_fout, "10620\n");
      fflush(_coverage_fout);
      }
      occ = tif->tif_rawdatasize - tif->tif_rawcc;
    } else {
      {
      fprintf(_coverage_fout, "10621\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "10626\n");
    fflush(_coverage_fout);
    }
    tmp___0 = op;
    {
    fprintf(_coverage_fout, "10627\n");
    fflush(_coverage_fout);
    }
    op ++;
    {
    fprintf(_coverage_fout, "10628\n");
    fflush(_coverage_fout);
    }
    *tmp___0 = (unsigned char )(*tp >> 16);
    {
    fprintf(_coverage_fout, "10629\n");
    fflush(_coverage_fout);
    }
    tmp___1 = op;
    {
    fprintf(_coverage_fout, "10630\n");
    fflush(_coverage_fout);
    }
    op ++;
    {
    fprintf(_coverage_fout, "10631\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = (unsigned char )((*tp >> 8) & 255U);
    {
    fprintf(_coverage_fout, "10632\n");
    fflush(_coverage_fout);
    }
    tmp___2 = op;
    {
    fprintf(_coverage_fout, "10633\n");
    fflush(_coverage_fout);
    }
    op ++;
    {
    fprintf(_coverage_fout, "10634\n");
    fflush(_coverage_fout);
    }
    tmp___3 = tp;
    {
    fprintf(_coverage_fout, "10635\n");
    fflush(_coverage_fout);
    }
    tp ++;
    {
    fprintf(_coverage_fout, "10636\n");
    fflush(_coverage_fout);
    }
    *tmp___2 = (unsigned char )(*tmp___3 & 255U);
    {
    fprintf(_coverage_fout, "10637\n");
    fflush(_coverage_fout);
    }
    occ -= 3L;
  }
  {
  fprintf(_coverage_fout, "10647\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcp = op;
  {
  fprintf(_coverage_fout, "10648\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcc = tif->tif_rawdatasize - occ;
  {
  fprintf(_coverage_fout, "10649\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int LogLuvEncode32(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ LogLuvState *sp ;
  int shft ;
  tmsize_t i ;
  tmsize_t j ;
  tmsize_t npixels ;
  uint8 *op ;
  uint32 *tp ;
  uint32 b ;
  tmsize_t occ ;
  int rc ;
  int mask ;
  tmsize_t beg ;
  int tmp ;
  uint8 *tmp___0 ;
  uint8 *tmp___1 ;
  tmsize_t tmp___2 ;
  int tmp___3 ;
  uint8 *tmp___4 ;
  uint8 *tmp___5 ;
  tmsize_t tmp___6 ;
  tmsize_t tmp___7 ;
  uint8 *tmp___8 ;
  uint8 *tmp___9 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10756\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "10757\n");
  fflush(_coverage_fout);
  }
  rc = 0;
  {
  fprintf(_coverage_fout, "10758\n");
  fflush(_coverage_fout);
  }
  if ((int )s == 0) {
    {
    fprintf(_coverage_fout, "10650\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10651\n");
    fflush(_coverage_fout);
    }
    __assert_fail("s == 0", "tif_luv.c", 538U, "LogLuvEncode32");
  }
  {
  fprintf(_coverage_fout, "10759\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "10652\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10653\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 539U, "LogLuvEncode32");
  }
  {
  fprintf(_coverage_fout, "10760\n");
  fflush(_coverage_fout);
  }
  npixels = cc / (tmsize_t )sp->pixel_size;
  {
  fprintf(_coverage_fout, "10761\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == 2) {
    {
    fprintf(_coverage_fout, "10654\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)bp;
  } else {
    {
    fprintf(_coverage_fout, "10657\n");
    fflush(_coverage_fout);
    }
    tp = (uint32 *)sp->tbuf;
    {
    fprintf(_coverage_fout, "10658\n");
    fflush(_coverage_fout);
    }
    if (sp->tbuflen >= npixels) {
      {
      fprintf(_coverage_fout, "10655\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "10656\n");
      fflush(_coverage_fout);
      }
      __assert_fail("sp->tbuflen >= npixels", "tif_luv.c", 547U,
                    "LogLuvEncode32");
    }
    {
    fprintf(_coverage_fout, "10659\n");
    fflush(_coverage_fout);
    }
    (*(sp->tfunc))(sp, bp, npixels);
  }
  {
  fprintf(_coverage_fout, "10762\n");
  fflush(_coverage_fout);
  }
  op = tif->tif_rawcp;
  {
  fprintf(_coverage_fout, "10763\n");
  fflush(_coverage_fout);
  }
  occ = tif->tif_rawdatasize - tif->tif_rawcc;
  {
  fprintf(_coverage_fout, "10764\n");
  fflush(_coverage_fout);
  }
  shft = 32;
  {
  fprintf(_coverage_fout, "10765\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10752\n");
    fflush(_coverage_fout);
    }
    shft -= 8;
    {
    fprintf(_coverage_fout, "10753\n");
    fflush(_coverage_fout);
    }
    if (shft >= 0) {
      {
      fprintf(_coverage_fout, "10660\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10754\n");
    fflush(_coverage_fout);
    }
    i = 0L;
    {
    fprintf(_coverage_fout, "10755\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10743\n");
      fflush(_coverage_fout);
      }
      if (i < npixels) {
        {
        fprintf(_coverage_fout, "10661\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10744\n");
      fflush(_coverage_fout);
      }
      if (occ < 4L) {
        {
        fprintf(_coverage_fout, "10664\n");
        fflush(_coverage_fout);
        }
        tif->tif_rawcp = op;
        {
        fprintf(_coverage_fout, "10665\n");
        fflush(_coverage_fout);
        }
        tif->tif_rawcc = tif->tif_rawdatasize - occ;
        {
        fprintf(_coverage_fout, "10666\n");
        fflush(_coverage_fout);
        }
        tmp = TIFFFlushData1(tif);
        {
        fprintf(_coverage_fout, "10667\n");
        fflush(_coverage_fout);
        }
        if (tmp) {
          {
          fprintf(_coverage_fout, "10662\n");
          fflush(_coverage_fout);
          }

        } else {
          {
          fprintf(_coverage_fout, "10663\n");
          fflush(_coverage_fout);
          }
          return (-1);
        }
        {
        fprintf(_coverage_fout, "10668\n");
        fflush(_coverage_fout);
        }
        op = tif->tif_rawcp;
        {
        fprintf(_coverage_fout, "10669\n");
        fflush(_coverage_fout);
        }
        occ = tif->tif_rawdatasize - tif->tif_rawcc;
      } else {
        {
        fprintf(_coverage_fout, "10670\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "10745\n");
      fflush(_coverage_fout);
      }
      mask = 0xff << shft;
      {
      fprintf(_coverage_fout, "10746\n");
      fflush(_coverage_fout);
      }
      beg = i;
      {
      fprintf(_coverage_fout, "10747\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "10678\n");
        fflush(_coverage_fout);
        }
        if (beg < npixels) {
          {
          fprintf(_coverage_fout, "10671\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "10679\n");
        fflush(_coverage_fout);
        }
        b = *(tp + beg) & (unsigned int )mask;
        {
        fprintf(_coverage_fout, "10680\n");
        fflush(_coverage_fout);
        }
        rc = 1;
        {
        fprintf(_coverage_fout, "10681\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10675\n");
          fflush(_coverage_fout);
          }
          if (rc < 129) {
            {
            fprintf(_coverage_fout, "10674\n");
            fflush(_coverage_fout);
            }
            if (beg + (tmsize_t )rc < npixels) {
              {
              fprintf(_coverage_fout, "10673\n");
              fflush(_coverage_fout);
              }
              if ((*(tp + (beg + (tmsize_t )rc)) & (unsigned int )mask) == b) {
                {
                fprintf(_coverage_fout, "10672\n");
                fflush(_coverage_fout);
                }

              } else {
                break;
              }
            } else {
              break;
            }
          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10676\n");
          fflush(_coverage_fout);
          }
          rc ++;
        }
        {
        fprintf(_coverage_fout, "10682\n");
        fflush(_coverage_fout);
        }
        if (rc >= 4) {
          break;
        } else {
          {
          fprintf(_coverage_fout, "10677\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10683\n");
        fflush(_coverage_fout);
        }
        beg += (tmsize_t )rc;
      }
      {
      fprintf(_coverage_fout, "10748\n");
      fflush(_coverage_fout);
      }
      if (beg - i > 1L) {
        {
        fprintf(_coverage_fout, "10702\n");
        fflush(_coverage_fout);
        }
        if (beg - i < 4L) {
          {
          fprintf(_coverage_fout, "10698\n");
          fflush(_coverage_fout);
          }
          b = *(tp + i) & (unsigned int )mask;
          {
          fprintf(_coverage_fout, "10699\n");
          fflush(_coverage_fout);
          }
          j = i + 1L;
          {
          fprintf(_coverage_fout, "10700\n");
          fflush(_coverage_fout);
          }
          while (1) {
            {
            fprintf(_coverage_fout, "10694\n");
            fflush(_coverage_fout);
            }
            tmp___2 = j;
            {
            fprintf(_coverage_fout, "10695\n");
            fflush(_coverage_fout);
            }
            j ++;
            {
            fprintf(_coverage_fout, "10696\n");
            fflush(_coverage_fout);
            }
            if ((*(tp + tmp___2) & (unsigned int )mask) == b) {
              {
              fprintf(_coverage_fout, "10684\n");
              fflush(_coverage_fout);
              }

            } else {
              break;
            }
            {
            fprintf(_coverage_fout, "10697\n");
            fflush(_coverage_fout);
            }
            if (j == beg) {
              {
              fprintf(_coverage_fout, "10685\n");
              fflush(_coverage_fout);
              }
              tmp___0 = op;
              {
              fprintf(_coverage_fout, "10686\n");
              fflush(_coverage_fout);
              }
              op ++;
              {
              fprintf(_coverage_fout, "10687\n");
              fflush(_coverage_fout);
              }
              *tmp___0 = (unsigned char )((126L + j) - i);
              {
              fprintf(_coverage_fout, "10688\n");
              fflush(_coverage_fout);
              }
              tmp___1 = op;
              {
              fprintf(_coverage_fout, "10689\n");
              fflush(_coverage_fout);
              }
              op ++;
              {
              fprintf(_coverage_fout, "10690\n");
              fflush(_coverage_fout);
              }
              *tmp___1 = (unsigned char )(b >> shft);
              {
              fprintf(_coverage_fout, "10691\n");
              fflush(_coverage_fout);
              }
              occ -= 2L;
              {
              fprintf(_coverage_fout, "10692\n");
              fflush(_coverage_fout);
              }
              i = beg;
              break;
            } else {
              {
              fprintf(_coverage_fout, "10693\n");
              fflush(_coverage_fout);
              }

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

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

      }
      {
      fprintf(_coverage_fout, "10749\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "10726\n");
        fflush(_coverage_fout);
        }
        if (i < beg) {
          {
          fprintf(_coverage_fout, "10704\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "10727\n");
        fflush(_coverage_fout);
        }
        j = beg - i;
        {
        fprintf(_coverage_fout, "10728\n");
        fflush(_coverage_fout);
        }
        if (j > 127L) {
          {
          fprintf(_coverage_fout, "10705\n");
          fflush(_coverage_fout);
          }
          j = 127L;
        } else {
          {
          fprintf(_coverage_fout, "10706\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10729\n");
        fflush(_coverage_fout);
        }
        if (occ < j + 3L) {
          {
          fprintf(_coverage_fout, "10709\n");
          fflush(_coverage_fout);
          }
          tif->tif_rawcp = op;
          {
          fprintf(_coverage_fout, "10710\n");
          fflush(_coverage_fout);
          }
          tif->tif_rawcc = tif->tif_rawdatasize - occ;
          {
          fprintf(_coverage_fout, "10711\n");
          fflush(_coverage_fout);
          }
          tmp___3 = TIFFFlushData1(tif);
          {
          fprintf(_coverage_fout, "10712\n");
          fflush(_coverage_fout);
          }
          if (tmp___3) {
            {
            fprintf(_coverage_fout, "10707\n");
            fflush(_coverage_fout);
            }

          } else {
            {
            fprintf(_coverage_fout, "10708\n");
            fflush(_coverage_fout);
            }
            return (-1);
          }
          {
          fprintf(_coverage_fout, "10713\n");
          fflush(_coverage_fout);
          }
          op = tif->tif_rawcp;
          {
          fprintf(_coverage_fout, "10714\n");
          fflush(_coverage_fout);
          }
          occ = tif->tif_rawdatasize - tif->tif_rawcc;
        } else {
          {
          fprintf(_coverage_fout, "10715\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10730\n");
        fflush(_coverage_fout);
        }
        tmp___4 = op;
        {
        fprintf(_coverage_fout, "10731\n");
        fflush(_coverage_fout);
        }
        op ++;
        {
        fprintf(_coverage_fout, "10732\n");
        fflush(_coverage_fout);
        }
        *tmp___4 = (unsigned char )j;
        {
        fprintf(_coverage_fout, "10733\n");
        fflush(_coverage_fout);
        }
        occ --;
        {
        fprintf(_coverage_fout, "10734\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10717\n");
          fflush(_coverage_fout);
          }
          tmp___7 = j;
          {
          fprintf(_coverage_fout, "10718\n");
          fflush(_coverage_fout);
          }
          j --;
          {
          fprintf(_coverage_fout, "10719\n");
          fflush(_coverage_fout);
          }
          if (tmp___7) {
            {
            fprintf(_coverage_fout, "10716\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10720\n");
          fflush(_coverage_fout);
          }
          tmp___5 = op;
          {
          fprintf(_coverage_fout, "10721\n");
          fflush(_coverage_fout);
          }
          op ++;
          {
          fprintf(_coverage_fout, "10722\n");
          fflush(_coverage_fout);
          }
          tmp___6 = i;
          {
          fprintf(_coverage_fout, "10723\n");
          fflush(_coverage_fout);
          }
          i ++;
          {
          fprintf(_coverage_fout, "10724\n");
          fflush(_coverage_fout);
          }
          *tmp___5 = (unsigned char )((*(tp + tmp___6) >> shft) & 255U);
          {
          fprintf(_coverage_fout, "10725\n");
          fflush(_coverage_fout);
          }
          occ --;
        }
      }
      {
      fprintf(_coverage_fout, "10750\n");
      fflush(_coverage_fout);
      }
      if (rc >= 4) {
        {
        fprintf(_coverage_fout, "10735\n");
        fflush(_coverage_fout);
        }
        tmp___8 = op;
        {
        fprintf(_coverage_fout, "10736\n");
        fflush(_coverage_fout);
        }
        op ++;
        {
        fprintf(_coverage_fout, "10737\n");
        fflush(_coverage_fout);
        }
        *tmp___8 = (unsigned char )(126 + rc);
        {
        fprintf(_coverage_fout, "10738\n");
        fflush(_coverage_fout);
        }
        tmp___9 = op;
        {
        fprintf(_coverage_fout, "10739\n");
        fflush(_coverage_fout);
        }
        op ++;
        {
        fprintf(_coverage_fout, "10740\n");
        fflush(_coverage_fout);
        }
        *tmp___9 = (unsigned char )((*(tp + beg) >> shft) & 255U);
        {
        fprintf(_coverage_fout, "10741\n");
        fflush(_coverage_fout);
        }
        occ -= 2L;
      } else {
        {
        fprintf(_coverage_fout, "10742\n");
        fflush(_coverage_fout);
        }
        rc = 0;
      }
      {
      fprintf(_coverage_fout, "10751\n");
      fflush(_coverage_fout);
      }
      i += (tmsize_t )rc;
    }
  }
  {
  fprintf(_coverage_fout, "10766\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcp = op;
  {
  fprintf(_coverage_fout, "10767\n");
  fflush(_coverage_fout);
  }
  tif->tif_rawcc = tif->tif_rawdatasize - occ;
  {
  fprintf(_coverage_fout, "10768\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int LogLuvEncodeStrip(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ tmsize_t rowlen ;
  tmsize_t tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10777\n");
  fflush(_coverage_fout);
  }
  tmp = TIFFScanlineSize(tif);
  {
  fprintf(_coverage_fout, "10778\n");
  fflush(_coverage_fout);
  }
  rowlen = tmp;
  {
  fprintf(_coverage_fout, "10779\n");
  fflush(_coverage_fout);
  }
  if (cc % rowlen == 0L) {
    {
    fprintf(_coverage_fout, "10769\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10770\n");
    fflush(_coverage_fout);
    }
    __assert_fail("cc%rowlen == 0", "tif_luv.c", 623U, "LogLuvEncodeStrip");
  }
  {
  fprintf(_coverage_fout, "10780\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10774\n");
    fflush(_coverage_fout);
    }
    if (cc) {
      {
      fprintf(_coverage_fout, "10772\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (*(tif->tif_encoderow))(tif, bp, rowlen, s);
      {
      fprintf(_coverage_fout, "10773\n");
      fflush(_coverage_fout);
      }
      if (tmp___0 == 0) {
        {
        fprintf(_coverage_fout, "10771\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10775\n");
    fflush(_coverage_fout);
    }
    bp += rowlen;
    {
    fprintf(_coverage_fout, "10776\n");
    fflush(_coverage_fout);
    }
    cc -= rowlen;
  }
  {
  fprintf(_coverage_fout, "10781\n");
  fflush(_coverage_fout);
  }
  return (cc == 0L);
}
}
static int LogLuvEncodeTile(TIFF *tif , uint8 *bp , tmsize_t cc , uint16 s ) 
{ tmsize_t rowlen ;
  tmsize_t tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10790\n");
  fflush(_coverage_fout);
  }
  tmp = TIFFTileRowSize(tif);
  {
  fprintf(_coverage_fout, "10791\n");
  fflush(_coverage_fout);
  }
  rowlen = tmp;
  {
  fprintf(_coverage_fout, "10792\n");
  fflush(_coverage_fout);
  }
  if (cc % rowlen == 0L) {
    {
    fprintf(_coverage_fout, "10782\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "10783\n");
    fflush(_coverage_fout);
    }
    __assert_fail("cc%rowlen == 0", "tif_luv.c", 638U, "LogLuvEncodeTile");
  }
  {
  fprintf(_coverage_fout, "10793\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10787\n");
    fflush(_coverage_fout);
    }
    if (cc) {
      {
      fprintf(_coverage_fout, "10785\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (*(tif->tif_encoderow))(tif, bp, rowlen, s);
      {
      fprintf(_coverage_fout, "10786\n");
      fflush(_coverage_fout);
      }
      if (tmp___0 == 0) {
        {
        fprintf(_coverage_fout, "10784\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10788\n");
    fflush(_coverage_fout);
    }
    bp += rowlen;
    {
    fprintf(_coverage_fout, "10789\n");
    fflush(_coverage_fout);
    }
    cc -= rowlen;
  }
  {
  fprintf(_coverage_fout, "10794\n");
  fflush(_coverage_fout);
  }
  return (cc == 0L);
}
}
static struct __anonstruct_uv_row_52 uv_row[163]  = 
  {      {(float )0.247663, (short)4, (short)0}, 
        {(float )0.243779, (short)6, (short)4}, 
        {(float )0.241684, (short)7, (short)10}, 
        {(float )0.237874, (short)9, (short)17}, 
        {(float )0.235906, (short)10, (short)26}, 
        {(float )0.232153, (short)12, (short)36}, 
        {(float )0.228352, (short)14, (short)48}, 
        {(float )0.226259, (short)15, (short)62}, 
        {(float )0.222371, (short)17, (short)77}, 
        {(float )0.220410, (short)18, (short)94}, 
        {(float )0.214710, (short)21, (short)112}, 
        {(float )0.212714, (short)22, (short)133}, 
        {(float )0.210721, (short)23, (short)155}, 
        {(float )0.204976, (short)26, (short)178}, 
        {(float )0.202986, (short)27, (short)204}, 
        {(float )0.199245, (short)29, (short)231}, 
        {(float )0.195525, (short)31, (short)260}, 
        {(float )0.193560, (short)32, (short)291}, 
        {(float )0.189878, (short)34, (short)323}, 
        {(float )0.186216, (short)36, (short)357}, 
        {(float )0.186216, (short)36, (short)393}, 
        {(float )0.182592, (short)38, (short)429}, 
        {(float )0.179003, (short)40, (short)467}, 
        {(float )0.175466, (short)42, (short)507}, 
        {(float )0.172001, (short)44, (short)549}, 
        {(float )0.172001, (short)44, (short)593}, 
        {(float )0.168612, (short)46, (short)637}, 
        {(float )0.168612, (short)46, (short)683}, 
        {(float )0.163575, (short)49, (short)729}, 
        {(float )0.158642, (short)52, (short)778}, 
        {(float )0.158642, (short)52, (short)830}, 
        {(float )0.158642, (short)52, (short)882}, 
        {(float )0.153815, (short)55, (short)934}, 
        {(float )0.153815, (short)55, (short)989}, 
        {(float )0.149097, (short)58, (short)1044}, 
        {(float )0.149097, (short)58, (short)1102}, 
        {(float )0.142746, (short)62, (short)1160}, 
        {(float )0.142746, (short)62, (short)1222}, 
        {(float )0.142746, (short)62, (short)1284}, 
        {(float )0.138270, (short)65, (short)1346}, 
        {(float )0.138270, (short)65, (short)1411}, 
        {(float )0.138270, (short)65, (short)1476}, 
        {(float )0.132166, (short)69, (short)1541}, 
        {(float )0.132166, (short)69, (short)1610}, 
        {(float )0.126204, (short)73, (short)1679}, 
        {(float )0.126204, (short)73, (short)1752}, 
        {(float )0.126204, (short)73, (short)1825}, 
        {(float )0.120381, (short)77, (short)1898}, 
        {(float )0.120381, (short)77, (short)1975}, 
        {(float )0.120381, (short)77, (short)2052}, 
        {(float )0.120381, (short)77, (short)2129}, 
        {(float )0.112962, (short)82, (short)2206}, 
        {(float )0.112962, (short)82, (short)2288}, 
        {(float )0.112962, (short)82, (short)2370}, 
        {(float )0.107450, (short)86, (short)2452}, 
        {(float )0.107450, (short)86, (short)2538}, 
        {(float )0.107450, (short)86, (short)2624}, 
        {(float )0.107450, (short)86, (short)2710}, 
        {(float )0.100343, (short)91, (short)2796}, 
        {(float )0.100343, (short)91, (short)2887}, 
        {(float )0.100343, (short)91, (short)2978}, 
        {(float )0.095126, (short)95, (short)3069}, 
        {(float )0.095126, (short)95, (short)3164}, 
        {(float )0.095126, (short)95, (short)3259}, 
        {(float )0.095126, (short)95, (short)3354}, 
        {(float )0.088276, (short)100, (short)3449}, 
        {(float )0.088276, (short)100, (short)3549}, 
        {(float )0.088276, (short)100, (short)3649}, 
        {(float )0.088276, (short)100, (short)3749}, 
        {(float )0.081523, (short)105, (short)3849}, 
        {(float )0.081523, (short)105, (short)3954}, 
        {(float )0.081523, (short)105, (short)4059}, 
        {(float )0.081523, (short)105, (short)4164}, 
        {(float )0.074861, (short)110, (short)4269}, 
        {(float )0.074861, (short)110, (short)4379}, 
        {(float )0.074861, (short)110, (short)4489}, 
        {(float )0.074861, (short)110, (short)4599}, 
        {(float )0.068290, (short)115, (short)4709}, 
        {(float )0.068290, (short)115, (short)4824}, 
        {(float )0.068290, (short)115, (short)4939}, 
        {(float )0.068290, (short)115, (short)5054}, 
        {(float )0.063573, (short)119, (short)5169}, 
        {(float )0.063573, (short)119, (short)5288}, 
        {(float )0.063573, (short)119, (short)5407}, 
        {(float )0.063573, (short)119, (short)5526}, 
        {(float )0.057219, (short)124, (short)5645}, 
        {(float )0.057219, (short)124, (short)5769}, 
        {(float )0.057219, (short)124, (short)5893}, 
        {(float )0.057219, (short)124, (short)6017}, 
        {(float )0.050985, (short)129, (short)6141}, 
        {(float )0.050985, (short)129, (short)6270}, 
        {(float )0.050985, (short)129, (short)6399}, 
        {(float )0.050985, (short)129, (short)6528}, 
        {(float )0.050985, (short)129, (short)6657}, 
        {(float )0.044859, (short)134, (short)6786}, 
        {(float )0.044859, (short)134, (short)6920}, 
        {(float )0.044859, (short)134, (short)7054}, 
        {(float )0.044859, (short)134, (short)7188}, 
        {(float )0.040571, (short)138, (short)7322}, 
        {(float )0.040571, (short)138, (short)7460}, 
        {(float )0.040571, (short)138, (short)7598}, 
        {(float )0.040571, (short)138, (short)7736}, 
        {(float )0.036339, (short)142, (short)7874}, 
        {(float )0.036339, (short)142, (short)8016}, 
        {(float )0.036339, (short)142, (short)8158}, 
        {(float )0.036339, (short)142, (short)8300}, 
        {(float )0.032139, (short)146, (short)8442}, 
        {(float )0.032139, (short)146, (short)8588}, 
        {(float )0.032139, (short)146, (short)8734}, 
        {(float )0.032139, (short)146, (short)8880}, 
        {(float )0.027947, (short)150, (short)9026}, 
        {(float )0.027947, (short)150, (short)9176}, 
        {(float )0.027947, (short)150, (short)9326}, 
        {(float )0.023739, (short)154, (short)9476}, 
        {(float )0.023739, (short)154, (short)9630}, 
        {(float )0.023739, (short)154, (short)9784}, 
        {(float )0.023739, (short)154, (short)9938}, 
        {(float )0.019504, (short)158, (short)10092}, 
        {(float )0.019504, (short)158, (short)10250}, 
        {(float )0.019504, (short)158, (short)10408}, 
        {(float )0.016976, (short)161, (short)10566}, 
        {(float )0.016976, (short)161, (short)10727}, 
        {(float )0.016976, (short)161, (short)10888}, 
        {(float )0.016976, (short)161, (short)11049}, 
        {(float )0.012639, (short)165, (short)11210}, 
        {(float )0.012639, (short)165, (short)11375}, 
        {(float )0.012639, (short)165, (short)11540}, 
        {(float )0.009991, (short)168, (short)11705}, 
        {(float )0.009991, (short)168, (short)11873}, 
        {(float )0.009991, (short)168, (short)12041}, 
        {(float )0.009016, (short)170, (short)12209}, 
        {(float )0.009016, (short)170, (short)12379}, 
        {(float )0.009016, (short)170, (short)12549}, 
        {(float )0.006217, (short)173, (short)12719}, 
        {(float )0.006217, (short)173, (short)12892}, 
        {(float )0.005097, (short)175, (short)13065}, 
        {(float )0.005097, (short)175, (short)13240}, 
        {(float )0.005097, (short)175, (short)13415}, 
        {(float )0.003909, (short)177, (short)13590}, 
        {(float )0.003909, (short)177, (short)13767}, 
        {(float )0.002340, (short)177, (short)13944}, 
        {(float )0.002389, (short)170, (short)14121}, 
        {(float )0.001068, (short)164, (short)14291}, 
        {(float )0.001653, (short)157, (short)14455}, 
        {(float )0.000717, (short)150, (short)14612}, 
        {(float )0.001614, (short)143, (short)14762}, 
        {(float )0.000270, (short)136, (short)14905}, 
        {(float )0.000484, (short)129, (short)15041}, 
        {(float )0.001103, (short)123, (short)15170}, 
        {(float )0.001242, (short)115, (short)15293}, 
        {(float )0.001188, (short)109, (short)15408}, 
        {(float )0.001011, (short)103, (short)15517}, 
        {(float )0.000709, (short)97, (short)15620}, 
        {(float )0.000301, (short)89, (short)15717}, 
        {(float )0.002416, (short)82, (short)15806}, 
        {(float )0.003251, (short)76, (short)15888}, 
        {(float )0.003246, (short)69, (short)15964}, 
        {(float )0.004141, (short)62, (short)16033}, 
        {(float )0.005963, (short)55, (short)16095}, 
        {(float )0.008839, (short)47, (short)16150}, 
        {(float )0.010490, (short)40, (short)16197}, 
        {(float )0.016994, (short)31, (short)16237}, 
        {(float )0.023659, (short)21, (short)16268}};
double LogL16toY(int p16 ) 
{ int Le ;
  double Y ;
  double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10799\n");
  fflush(_coverage_fout);
  }
  Le = p16 & 0x7fff;
  {
  fprintf(_coverage_fout, "10800\n");
  fflush(_coverage_fout);
  }
  if (! Le) {
    {
    fprintf(_coverage_fout, "10795\n");
    fflush(_coverage_fout);
    }
    return (0.);
  } else {
    {
    fprintf(_coverage_fout, "10796\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10801\n");
  fflush(_coverage_fout);
  }
  Y = exp((0.69314718055994530942 / 256.) * ((double )Le + .5) - 0.69314718055994530942 * 64.);
  {
  fprintf(_coverage_fout, "10802\n");
  fflush(_coverage_fout);
  }
  if (! (p16 & 0x8000)) {
    {
    fprintf(_coverage_fout, "10797\n");
    fflush(_coverage_fout);
    }
    tmp = Y;
  } else {
    {
    fprintf(_coverage_fout, "10798\n");
    fflush(_coverage_fout);
    }
    tmp = - Y;
  }
  {
  fprintf(_coverage_fout, "10803\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
int LogL16fromY(double Y , int em ) 
{ double tmp ;
  double tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  double tmp___3 ;
  double tmp___4 ;
  int tmp___5 ;
  int tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10824\n");
  fflush(_coverage_fout);
  }
  if (Y >= 1.8371976e19) {
    {
    fprintf(_coverage_fout, "10804\n");
    fflush(_coverage_fout);
    }
    return (0x7fff);
  } else {
    {
    fprintf(_coverage_fout, "10805\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10825\n");
  fflush(_coverage_fout);
  }
  if (Y <= - 1.8371976e19) {
    {
    fprintf(_coverage_fout, "10806\n");
    fflush(_coverage_fout);
    }
    return (0xffff);
  } else {
    {
    fprintf(_coverage_fout, "10807\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10826\n");
  fflush(_coverage_fout);
  }
  if (Y > 5.4136769e-20) {
    {
    fprintf(_coverage_fout, "10813\n");
    fflush(_coverage_fout);
    }
    if (em == 0) {
      {
      fprintf(_coverage_fout, "10808\n");
      fflush(_coverage_fout);
      }
      tmp = log(Y);
      {
      fprintf(_coverage_fout, "10809\n");
      fflush(_coverage_fout);
      }
      tmp___2 = (int )(256. * ((1. / 0.69314718055994530942) * tmp + 64.));
    } else {
      {
      fprintf(_coverage_fout, "10810\n");
      fflush(_coverage_fout);
      }
      tmp___0 = log(Y);
      {
      fprintf(_coverage_fout, "10811\n");
      fflush(_coverage_fout);
      }
      tmp___1 = rand();
      {
      fprintf(_coverage_fout, "10812\n");
      fflush(_coverage_fout);
      }
      tmp___2 = (int )((256. * ((1. / 0.69314718055994530942) * tmp___0 + 64.) + (double )tmp___1 * (1. / (double )2147483647)) - .5);
    }
    {
    fprintf(_coverage_fout, "10814\n");
    fflush(_coverage_fout);
    }
    return (tmp___2);
  } else {
    {
    fprintf(_coverage_fout, "10815\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10827\n");
  fflush(_coverage_fout);
  }
  if (Y < - 5.4136769e-20) {
    {
    fprintf(_coverage_fout, "10821\n");
    fflush(_coverage_fout);
    }
    if (em == 0) {
      {
      fprintf(_coverage_fout, "10816\n");
      fflush(_coverage_fout);
      }
      tmp___3 = log(- Y);
      {
      fprintf(_coverage_fout, "10817\n");
      fflush(_coverage_fout);
      }
      tmp___6 = (int )(256. * ((1. / 0.69314718055994530942) * tmp___3 + 64.));
    } else {
      {
      fprintf(_coverage_fout, "10818\n");
      fflush(_coverage_fout);
      }
      tmp___4 = log(- Y);
      {
      fprintf(_coverage_fout, "10819\n");
      fflush(_coverage_fout);
      }
      tmp___5 = rand();
      {
      fprintf(_coverage_fout, "10820\n");
      fflush(_coverage_fout);
      }
      tmp___6 = (int )((256. * ((1. / 0.69314718055994530942) * tmp___4 + 64.) + (double )tmp___5 * (1. / (double )2147483647)) - .5);
    }
    {
    fprintf(_coverage_fout, "10822\n");
    fflush(_coverage_fout);
    }
    return (-32768 | tmp___6);
  } else {
    {
    fprintf(_coverage_fout, "10823\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10828\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static void L16toY(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ int16 *l16 ;
  float *yp ;
  float *tmp ;
  int16 *tmp___0 ;
  double tmp___1 ;
  tmsize_t tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10839\n");
  fflush(_coverage_fout);
  }
  l16 = (int16 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "10840\n");
  fflush(_coverage_fout);
  }
  yp = (float *)op;
  {
  fprintf(_coverage_fout, "10841\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10830\n");
    fflush(_coverage_fout);
    }
    tmp___2 = n;
    {
    fprintf(_coverage_fout, "10831\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "10832\n");
    fflush(_coverage_fout);
    }
    if (tmp___2 > 0L) {
      {
      fprintf(_coverage_fout, "10829\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10833\n");
    fflush(_coverage_fout);
    }
    tmp = yp;
    {
    fprintf(_coverage_fout, "10834\n");
    fflush(_coverage_fout);
    }
    yp ++;
    {
    fprintf(_coverage_fout, "10835\n");
    fflush(_coverage_fout);
    }
    tmp___0 = l16;
    {
    fprintf(_coverage_fout, "10836\n");
    fflush(_coverage_fout);
    }
    l16 ++;
    {
    fprintf(_coverage_fout, "10837\n");
    fflush(_coverage_fout);
    }
    tmp___1 = LogL16toY((int )*tmp___0);
    {
    fprintf(_coverage_fout, "10838\n");
    fflush(_coverage_fout);
    }
    *tmp = (float )tmp___1;
  }
  {
  fprintf(_coverage_fout, "10842\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void L16toGry(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ int16 *l16 ;
  uint8 *gp ;
  double Y ;
  int16 *tmp ;
  double tmp___0 ;
  uint8 *tmp___1 ;
  double tmp___2 ;
  int tmp___3 ;
  int tmp___4 ;
  tmsize_t tmp___5 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10861\n");
  fflush(_coverage_fout);
  }
  l16 = (int16 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "10862\n");
  fflush(_coverage_fout);
  }
  gp = op;
  {
  fprintf(_coverage_fout, "10863\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10850\n");
    fflush(_coverage_fout);
    }
    tmp___5 = n;
    {
    fprintf(_coverage_fout, "10851\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "10852\n");
    fflush(_coverage_fout);
    }
    if (tmp___5 > 0L) {
      {
      fprintf(_coverage_fout, "10843\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10853\n");
    fflush(_coverage_fout);
    }
    tmp = l16;
    {
    fprintf(_coverage_fout, "10854\n");
    fflush(_coverage_fout);
    }
    l16 ++;
    {
    fprintf(_coverage_fout, "10855\n");
    fflush(_coverage_fout);
    }
    tmp___0 = LogL16toY((int )*tmp);
    {
    fprintf(_coverage_fout, "10856\n");
    fflush(_coverage_fout);
    }
    Y = tmp___0;
    {
    fprintf(_coverage_fout, "10857\n");
    fflush(_coverage_fout);
    }
    tmp___1 = gp;
    {
    fprintf(_coverage_fout, "10858\n");
    fflush(_coverage_fout);
    }
    gp ++;
    {
    fprintf(_coverage_fout, "10859\n");
    fflush(_coverage_fout);
    }
    if (Y <= 0.) {
      {
      fprintf(_coverage_fout, "10844\n");
      fflush(_coverage_fout);
      }
      tmp___4 = 0;
    } else {
      {
      fprintf(_coverage_fout, "10848\n");
      fflush(_coverage_fout);
      }
      if (Y >= 1.) {
        {
        fprintf(_coverage_fout, "10845\n");
        fflush(_coverage_fout);
        }
        tmp___3 = 255;
      } else {
        {
        fprintf(_coverage_fout, "10846\n");
        fflush(_coverage_fout);
        }
        tmp___2 = sqrt(Y);
        {
        fprintf(_coverage_fout, "10847\n");
        fflush(_coverage_fout);
        }
        tmp___3 = (int )(256. * tmp___2);
      }
      {
      fprintf(_coverage_fout, "10849\n");
      fflush(_coverage_fout);
      }
      tmp___4 = tmp___3;
    }
    {
    fprintf(_coverage_fout, "10860\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = (unsigned char )tmp___4;
  }
  {
  fprintf(_coverage_fout, "10864\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void L16fromY(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ int16 *l16 ;
  float *yp ;
  int16 *tmp ;
  float *tmp___0 ;
  int tmp___1 ;
  tmsize_t tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10875\n");
  fflush(_coverage_fout);
  }
  l16 = (int16 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "10876\n");
  fflush(_coverage_fout);
  }
  yp = (float *)op;
  {
  fprintf(_coverage_fout, "10877\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "10866\n");
    fflush(_coverage_fout);
    }
    tmp___2 = n;
    {
    fprintf(_coverage_fout, "10867\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "10868\n");
    fflush(_coverage_fout);
    }
    if (tmp___2 > 0L) {
      {
      fprintf(_coverage_fout, "10865\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "10869\n");
    fflush(_coverage_fout);
    }
    tmp = l16;
    {
    fprintf(_coverage_fout, "10870\n");
    fflush(_coverage_fout);
    }
    l16 ++;
    {
    fprintf(_coverage_fout, "10871\n");
    fflush(_coverage_fout);
    }
    tmp___0 = yp;
    {
    fprintf(_coverage_fout, "10872\n");
    fflush(_coverage_fout);
    }
    yp ++;
    {
    fprintf(_coverage_fout, "10873\n");
    fflush(_coverage_fout);
    }
    tmp___1 = LogL16fromY((double )*tmp___0, sp->encode_meth);
    {
    fprintf(_coverage_fout, "10874\n");
    fflush(_coverage_fout);
    }
    *tmp = (short )tmp___1;
  }
  {
  fprintf(_coverage_fout, "10878\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void XYZtoRGB24(float *xyz , uint8 *rgb ) 
{ double r ;
  double g ;
  double b ;
  double tmp ;
  int tmp___0 ;
  int tmp___1 ;
  double tmp___2 ;
  int tmp___3 ;
  int tmp___4 ;
  double tmp___5 ;
  int tmp___6 ;
  int tmp___7 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10897\n");
  fflush(_coverage_fout);
  }
  r = (2.690 * (double )*(xyz + 0) + - 1.276 * (double )*(xyz + 1)) + - 0.414 * (double )*(xyz + 2);
  {
  fprintf(_coverage_fout, "10898\n");
  fflush(_coverage_fout);
  }
  g = (- 1.022 * (double )*(xyz + 0) + 1.978 * (double )*(xyz + 1)) + 0.044 * (double )*(xyz + 2);
  {
  fprintf(_coverage_fout, "10899\n");
  fflush(_coverage_fout);
  }
  b = (0.061 * (double )*(xyz + 0) + - 0.224 * (double )*(xyz + 1)) + 1.163 * (double )*(xyz + 2);
  {
  fprintf(_coverage_fout, "10900\n");
  fflush(_coverage_fout);
  }
  if (r <= 0.) {
    {
    fprintf(_coverage_fout, "10879\n");
    fflush(_coverage_fout);
    }
    tmp___1 = 0;
  } else {
    {
    fprintf(_coverage_fout, "10883\n");
    fflush(_coverage_fout);
    }
    if (r >= 1.) {
      {
      fprintf(_coverage_fout, "10880\n");
      fflush(_coverage_fout);
      }
      tmp___0 = 255;
    } else {
      {
      fprintf(_coverage_fout, "10881\n");
      fflush(_coverage_fout);
      }
      tmp = sqrt(r);
      {
      fprintf(_coverage_fout, "10882\n");
      fflush(_coverage_fout);
      }
      tmp___0 = (int )(256. * tmp);
    }
    {
    fprintf(_coverage_fout, "10884\n");
    fflush(_coverage_fout);
    }
    tmp___1 = tmp___0;
  }
  {
  fprintf(_coverage_fout, "10901\n");
  fflush(_coverage_fout);
  }
  *(rgb + 0) = (unsigned char )tmp___1;
  {
  fprintf(_coverage_fout, "10902\n");
  fflush(_coverage_fout);
  }
  if (g <= 0.) {
    {
    fprintf(_coverage_fout, "10885\n");
    fflush(_coverage_fout);
    }
    tmp___4 = 0;
  } else {
    {
    fprintf(_coverage_fout, "10889\n");
    fflush(_coverage_fout);
    }
    if (g >= 1.) {
      {
      fprintf(_coverage_fout, "10886\n");
      fflush(_coverage_fout);
      }
      tmp___3 = 255;
    } else {
      {
      fprintf(_coverage_fout, "10887\n");
      fflush(_coverage_fout);
      }
      tmp___2 = sqrt(g);
      {
      fprintf(_coverage_fout, "10888\n");
      fflush(_coverage_fout);
      }
      tmp___3 = (int )(256. * tmp___2);
    }
    {
    fprintf(_coverage_fout, "10890\n");
    fflush(_coverage_fout);
    }
    tmp___4 = tmp___3;
  }
  {
  fprintf(_coverage_fout, "10903\n");
  fflush(_coverage_fout);
  }
  *(rgb + 1) = (unsigned char )tmp___4;
  {
  fprintf(_coverage_fout, "10904\n");
  fflush(_coverage_fout);
  }
  if (b <= 0.) {
    {
    fprintf(_coverage_fout, "10891\n");
    fflush(_coverage_fout);
    }
    tmp___7 = 0;
  } else {
    {
    fprintf(_coverage_fout, "10895\n");
    fflush(_coverage_fout);
    }
    if (b >= 1.) {
      {
      fprintf(_coverage_fout, "10892\n");
      fflush(_coverage_fout);
      }
      tmp___6 = 255;
    } else {
      {
      fprintf(_coverage_fout, "10893\n");
      fflush(_coverage_fout);
      }
      tmp___5 = sqrt(b);
      {
      fprintf(_coverage_fout, "10894\n");
      fflush(_coverage_fout);
      }
      tmp___6 = (int )(256. * tmp___5);
    }
    {
    fprintf(_coverage_fout, "10896\n");
    fflush(_coverage_fout);
    }
    tmp___7 = tmp___6;
  }
  {
  fprintf(_coverage_fout, "10905\n");
  fflush(_coverage_fout);
  }
  *(rgb + 2) = (unsigned char )tmp___7;
  {
  fprintf(_coverage_fout, "10906\n");
  fflush(_coverage_fout);
  }
  return;
}
}
double LogL10toY(int p10 ) 
{ double tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10909\n");
  fflush(_coverage_fout);
  }
  if (p10 == 0) {
    {
    fprintf(_coverage_fout, "10907\n");
    fflush(_coverage_fout);
    }
    return (0.);
  } else {
    {
    fprintf(_coverage_fout, "10908\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10910\n");
  fflush(_coverage_fout);
  }
  tmp = exp((0.69314718055994530942 / 64.) * ((double )p10 + .5) - 0.69314718055994530942 * 12.);
  {
  fprintf(_coverage_fout, "10911\n");
  fflush(_coverage_fout);
  }
  return (tmp);
}
}
int LogL10fromY(double Y , int em ) 
{ double tmp ;
  double tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10922\n");
  fflush(_coverage_fout);
  }
  if (Y >= 15.742) {
    {
    fprintf(_coverage_fout, "10912\n");
    fflush(_coverage_fout);
    }
    return (0x3ff);
  } else {
    {
    fprintf(_coverage_fout, "10921\n");
    fflush(_coverage_fout);
    }
    if (Y <= .00024283) {
      {
      fprintf(_coverage_fout, "10913\n");
      fflush(_coverage_fout);
      }
      return (0);
    } else {
      {
      fprintf(_coverage_fout, "10919\n");
      fflush(_coverage_fout);
      }
      if (em == 0) {
        {
        fprintf(_coverage_fout, "10914\n");
        fflush(_coverage_fout);
        }
        tmp = log(Y);
        {
        fprintf(_coverage_fout, "10915\n");
        fflush(_coverage_fout);
        }
        tmp___2 = (int )(64. * ((1. / 0.69314718055994530942) * tmp + 12.));
      } else {
        {
        fprintf(_coverage_fout, "10916\n");
        fflush(_coverage_fout);
        }
        tmp___0 = log(Y);
        {
        fprintf(_coverage_fout, "10917\n");
        fflush(_coverage_fout);
        }
        tmp___1 = rand();
        {
        fprintf(_coverage_fout, "10918\n");
        fflush(_coverage_fout);
        }
        tmp___2 = (int )((64. * ((1. / 0.69314718055994530942) * tmp___0 + 12.) + (double )tmp___1 * (1. / (double )2147483647)) - .5);
      }
      {
      fprintf(_coverage_fout, "10920\n");
      fflush(_coverage_fout);
      }
      return (tmp___2);
    }
  }
}
}
static int oog_table[100]  ;
static int oog_encode(double u , double v ) ;
static int initialized  =    0;
static int oog_encode(double u , double v ) 
{ register int i ;
  double eps[100] ;
  double ua ;
  double va ;
  double ang ;
  double epsa ;
  int ui ;
  int vi ;
  int ustep ;
  int tmp ;
  double tmp___0 ;
  int tmp___1 ;
  int i1 ;
  int i2 ;
  int tmp___2 ;
  double tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "10986\n");
  fflush(_coverage_fout);
  }
  if (! initialized) {
    {
    fprintf(_coverage_fout, "10978\n");
    fflush(_coverage_fout);
    }
    i = 100;
    {
    fprintf(_coverage_fout, "10979\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10924\n");
      fflush(_coverage_fout);
      }
      tmp = i;
      {
      fprintf(_coverage_fout, "10925\n");
      fflush(_coverage_fout);
      }
      i --;
      {
      fprintf(_coverage_fout, "10926\n");
      fflush(_coverage_fout);
      }
      if (tmp) {
        {
        fprintf(_coverage_fout, "10923\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10927\n");
      fflush(_coverage_fout);
      }
      eps[i] = 2.;
    }
    {
    fprintf(_coverage_fout, "10980\n");
    fflush(_coverage_fout);
    }
    vi = 163;
    {
    fprintf(_coverage_fout, "10981\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10947\n");
      fflush(_coverage_fout);
      }
      tmp___1 = vi;
      {
      fprintf(_coverage_fout, "10948\n");
      fflush(_coverage_fout);
      }
      vi --;
      {
      fprintf(_coverage_fout, "10949\n");
      fflush(_coverage_fout);
      }
      if (tmp___1) {
        {
        fprintf(_coverage_fout, "10928\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10950\n");
      fflush(_coverage_fout);
      }
      va = (double )((float )0.016940) + ((double )vi + .5) * (double )((float )0.003500);
      {
      fprintf(_coverage_fout, "10951\n");
      fflush(_coverage_fout);
      }
      ustep = (int )uv_row[vi].nus - 1;
      {
      fprintf(_coverage_fout, "10952\n");
      fflush(_coverage_fout);
      }
      if (vi == 162) {
        {
        fprintf(_coverage_fout, "10929\n");
        fflush(_coverage_fout);
        }
        ustep = 1;
      } else {
        {
        fprintf(_coverage_fout, "10934\n");
        fflush(_coverage_fout);
        }
        if (vi == 0) {
          {
          fprintf(_coverage_fout, "10930\n");
          fflush(_coverage_fout);
          }
          ustep = 1;
        } else {
          {
          fprintf(_coverage_fout, "10933\n");
          fflush(_coverage_fout);
          }
          if (ustep <= 0) {
            {
            fprintf(_coverage_fout, "10931\n");
            fflush(_coverage_fout);
            }
            ustep = 1;
          } else {
            {
            fprintf(_coverage_fout, "10932\n");
            fflush(_coverage_fout);
            }

          }
        }
      }
      {
      fprintf(_coverage_fout, "10953\n");
      fflush(_coverage_fout);
      }
      ui = (int )uv_row[vi].nus - 1;
      {
      fprintf(_coverage_fout, "10954\n");
      fflush(_coverage_fout);
      }
      while (1) {
        {
        fprintf(_coverage_fout, "10939\n");
        fflush(_coverage_fout);
        }
        if (ui >= 0) {
          {
          fprintf(_coverage_fout, "10935\n");
          fflush(_coverage_fout);
          }

        } else {
          break;
        }
        {
        fprintf(_coverage_fout, "10940\n");
        fflush(_coverage_fout);
        }
        ua = (double )uv_row[vi].ustart + ((double )ui + .5) * (double )((float )0.003500);
        {
        fprintf(_coverage_fout, "10941\n");
        fflush(_coverage_fout);
        }
        tmp___0 = atan2(va - 0.473684211, ua - 0.210526316);
        {
        fprintf(_coverage_fout, "10942\n");
        fflush(_coverage_fout);
        }
        ang = (((double )100 * .499999999) / 3.14159265358979323846) * tmp___0 + .5 * (double )100;
        {
        fprintf(_coverage_fout, "10943\n");
        fflush(_coverage_fout);
        }
        i = (int )ang;
        {
        fprintf(_coverage_fout, "10944\n");
        fflush(_coverage_fout);
        }
        epsa = fabs(ang - ((double )i + .5));
        {
        fprintf(_coverage_fout, "10945\n");
        fflush(_coverage_fout);
        }
        if (epsa < eps[i]) {
          {
          fprintf(_coverage_fout, "10936\n");
          fflush(_coverage_fout);
          }
          oog_table[i] = (int )uv_row[vi].ncum + ui;
          {
          fprintf(_coverage_fout, "10937\n");
          fflush(_coverage_fout);
          }
          eps[i] = epsa;
        } else {
          {
          fprintf(_coverage_fout, "10938\n");
          fflush(_coverage_fout);
          }

        }
        {
        fprintf(_coverage_fout, "10946\n");
        fflush(_coverage_fout);
        }
        ui -= ustep;
      }
    }
    {
    fprintf(_coverage_fout, "10982\n");
    fflush(_coverage_fout);
    }
    i = 100;
    {
    fprintf(_coverage_fout, "10983\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "10974\n");
      fflush(_coverage_fout);
      }
      tmp___2 = i;
      {
      fprintf(_coverage_fout, "10975\n");
      fflush(_coverage_fout);
      }
      i --;
      {
      fprintf(_coverage_fout, "10976\n");
      fflush(_coverage_fout);
      }
      if (tmp___2) {
        {
        fprintf(_coverage_fout, "10955\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "10977\n");
      fflush(_coverage_fout);
      }
      if (eps[i] > 1.5) {
        {
        fprintf(_coverage_fout, "10968\n");
        fflush(_coverage_fout);
        }
        i1 = 1;
        {
        fprintf(_coverage_fout, "10969\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10958\n");
          fflush(_coverage_fout);
          }
          if (i1 < 50) {
            {
            fprintf(_coverage_fout, "10956\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10959\n");
          fflush(_coverage_fout);
          }
          if (eps[(i + i1) % 100] < 1.5) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "10957\n");
            fflush(_coverage_fout);
            }

          }
          {
          fprintf(_coverage_fout, "10960\n");
          fflush(_coverage_fout);
          }
          i1 ++;
        }
        {
        fprintf(_coverage_fout, "10970\n");
        fflush(_coverage_fout);
        }
        i2 = 1;
        {
        fprintf(_coverage_fout, "10971\n");
        fflush(_coverage_fout);
        }
        while (1) {
          {
          fprintf(_coverage_fout, "10963\n");
          fflush(_coverage_fout);
          }
          if (i2 < 50) {
            {
            fprintf(_coverage_fout, "10961\n");
            fflush(_coverage_fout);
            }

          } else {
            break;
          }
          {
          fprintf(_coverage_fout, "10964\n");
          fflush(_coverage_fout);
          }
          if (eps[((i + 100) - i2) % 100] < 1.5) {
            break;
          } else {
            {
            fprintf(_coverage_fout, "10962\n");
            fflush(_coverage_fout);
            }

          }
          {
          fprintf(_coverage_fout, "10965\n");
          fflush(_coverage_fout);
          }
          i2 ++;
        }
        {
        fprintf(_coverage_fout, "10972\n");
        fflush(_coverage_fout);
        }
        if (i1 < i2) {
          {
          fprintf(_coverage_fout, "10966\n");
          fflush(_coverage_fout);
          }
          oog_table[i] = oog_table[(i + i1) % 100];
        } else {
          {
          fprintf(_coverage_fout, "10967\n");
          fflush(_coverage_fout);
          }
          oog_table[i] = oog_table[((i + 100) - i2) % 100];
        }
      } else {
        {
        fprintf(_coverage_fout, "10973\n");
        fflush(_coverage_fout);
        }

      }
    }
    {
    fprintf(_coverage_fout, "10984\n");
    fflush(_coverage_fout);
    }
    initialized = 1;
  } else {
    {
    fprintf(_coverage_fout, "10985\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10987\n");
  fflush(_coverage_fout);
  }
  tmp___3 = atan2(v - 0.473684211, u - 0.210526316);
  {
  fprintf(_coverage_fout, "10988\n");
  fflush(_coverage_fout);
  }
  i = (int )((((double )100 * .499999999) / 3.14159265358979323846) * tmp___3 + .5 * (double )100);
  {
  fprintf(_coverage_fout, "10989\n");
  fflush(_coverage_fout);
  }
  return (oog_table[i]);
}
}
int uv_encode(double u , double v , int em ) 
{ register int vi ;
  register int ui ;
  int tmp ;
  int tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  int tmp___4 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11008\n");
  fflush(_coverage_fout);
  }
  if (v < (double )((float )0.016940)) {
    {
    fprintf(_coverage_fout, "10990\n");
    fflush(_coverage_fout);
    }
    tmp = oog_encode(u, v);
    {
    fprintf(_coverage_fout, "10991\n");
    fflush(_coverage_fout);
    }
    return (tmp);
  } else {
    {
    fprintf(_coverage_fout, "10992\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11009\n");
  fflush(_coverage_fout);
  }
  if (em == 0) {
    {
    fprintf(_coverage_fout, "10993\n");
    fflush(_coverage_fout);
    }
    vi = (int )((v - (double )((float )0.016940)) * (1. / (double )((float )0.003500)));
  } else {
    {
    fprintf(_coverage_fout, "10994\n");
    fflush(_coverage_fout);
    }
    tmp___0 = rand();
    {
    fprintf(_coverage_fout, "10995\n");
    fflush(_coverage_fout);
    }
    vi = (int )(((v - (double )((float )0.016940)) * (1. / (double )((float )0.003500)) + (double )tmp___0 * (1. / (double )2147483647)) - .5);
  }
  {
  fprintf(_coverage_fout, "11010\n");
  fflush(_coverage_fout);
  }
  if (vi >= 163) {
    {
    fprintf(_coverage_fout, "10996\n");
    fflush(_coverage_fout);
    }
    tmp___1 = oog_encode(u, v);
    {
    fprintf(_coverage_fout, "10997\n");
    fflush(_coverage_fout);
    }
    return (tmp___1);
  } else {
    {
    fprintf(_coverage_fout, "10998\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11011\n");
  fflush(_coverage_fout);
  }
  if (u < (double )uv_row[vi].ustart) {
    {
    fprintf(_coverage_fout, "10999\n");
    fflush(_coverage_fout);
    }
    tmp___2 = oog_encode(u, v);
    {
    fprintf(_coverage_fout, "11000\n");
    fflush(_coverage_fout);
    }
    return (tmp___2);
  } else {
    {
    fprintf(_coverage_fout, "11001\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11012\n");
  fflush(_coverage_fout);
  }
  if (em == 0) {
    {
    fprintf(_coverage_fout, "11002\n");
    fflush(_coverage_fout);
    }
    ui = (int )((u - (double )uv_row[vi].ustart) * (1. / (double )((float )0.003500)));
  } else {
    {
    fprintf(_coverage_fout, "11003\n");
    fflush(_coverage_fout);
    }
    tmp___3 = rand();
    {
    fprintf(_coverage_fout, "11004\n");
    fflush(_coverage_fout);
    }
    ui = (int )(((u - (double )uv_row[vi].ustart) * (1. / (double )((float )0.003500)) + (double )tmp___3 * (1. / (double )2147483647)) - .5);
  }
  {
  fprintf(_coverage_fout, "11013\n");
  fflush(_coverage_fout);
  }
  if (ui >= (int )uv_row[vi].nus) {
    {
    fprintf(_coverage_fout, "11005\n");
    fflush(_coverage_fout);
    }
    tmp___4 = oog_encode(u, v);
    {
    fprintf(_coverage_fout, "11006\n");
    fflush(_coverage_fout);
    }
    return (tmp___4);
  } else {
    {
    fprintf(_coverage_fout, "11007\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11014\n");
  fflush(_coverage_fout);
  }
  return ((int )uv_row[vi].ncum + ui);
}
}
int uv_decode(double *up , double *vp , int c ) 
{ int upper ;
  int lower ;
  register int ui ;
  register int vi ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11028\n");
  fflush(_coverage_fout);
  }
  if (c < 0) {
    {
    fprintf(_coverage_fout, "11015\n");
    fflush(_coverage_fout);
    }
    return (-1);
  } else {
    {
    fprintf(_coverage_fout, "11018\n");
    fflush(_coverage_fout);
    }
    if (c >= 16289) {
      {
      fprintf(_coverage_fout, "11016\n");
      fflush(_coverage_fout);
      }
      return (-1);
    } else {
      {
      fprintf(_coverage_fout, "11017\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "11029\n");
  fflush(_coverage_fout);
  }
  lower = 0;
  {
  fprintf(_coverage_fout, "11030\n");
  fflush(_coverage_fout);
  }
  upper = 163;
  {
  fprintf(_coverage_fout, "11031\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11024\n");
    fflush(_coverage_fout);
    }
    if (upper - lower > 1) {
      {
      fprintf(_coverage_fout, "11019\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11025\n");
    fflush(_coverage_fout);
    }
    vi = (lower + upper) >> 1;
    {
    fprintf(_coverage_fout, "11026\n");
    fflush(_coverage_fout);
    }
    ui = c - (int )uv_row[vi].ncum;
    {
    fprintf(_coverage_fout, "11027\n");
    fflush(_coverage_fout);
    }
    if (ui > 0) {
      {
      fprintf(_coverage_fout, "11020\n");
      fflush(_coverage_fout);
      }
      lower = vi;
    } else {
      {
      fprintf(_coverage_fout, "11023\n");
      fflush(_coverage_fout);
      }
      if (ui < 0) {
        {
        fprintf(_coverage_fout, "11021\n");
        fflush(_coverage_fout);
        }
        upper = vi;
      } else {
        {
        fprintf(_coverage_fout, "11022\n");
        fflush(_coverage_fout);
        }
        lower = vi;
        break;
      }
    }
  }
  {
  fprintf(_coverage_fout, "11032\n");
  fflush(_coverage_fout);
  }
  vi = lower;
  {
  fprintf(_coverage_fout, "11033\n");
  fflush(_coverage_fout);
  }
  ui = c - (int )uv_row[vi].ncum;
  {
  fprintf(_coverage_fout, "11034\n");
  fflush(_coverage_fout);
  }
  *up = (double )uv_row[vi].ustart + ((double )ui + .5) * (double )((float )0.003500);
  {
  fprintf(_coverage_fout, "11035\n");
  fflush(_coverage_fout);
  }
  *vp = (double )((float )0.016940) + ((double )vi + .5) * (double )((float )0.003500);
  {
  fprintf(_coverage_fout, "11036\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
void LogLuv24toXYZ(uint32 p , float *XYZ ) 
{ int Ce ;
  double L ;
  double u ;
  double v ;
  double s ;
  double x ;
  double y ;
  float tmp ;
  float tmp___0 ;
  int tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11047\n");
  fflush(_coverage_fout);
  }
  L = LogL10toY((int )((p >> 14) & 1023U));
  {
  fprintf(_coverage_fout, "11048\n");
  fflush(_coverage_fout);
  }
  if (L <= 0.) {
    {
    fprintf(_coverage_fout, "11037\n");
    fflush(_coverage_fout);
    }
    tmp___0 = (float )0.;
    {
    fprintf(_coverage_fout, "11038\n");
    fflush(_coverage_fout);
    }
    *(XYZ + 2) = tmp___0;
    {
    fprintf(_coverage_fout, "11039\n");
    fflush(_coverage_fout);
    }
    tmp = tmp___0;
    {
    fprintf(_coverage_fout, "11040\n");
    fflush(_coverage_fout);
    }
    *(XYZ + 1) = tmp;
    {
    fprintf(_coverage_fout, "11041\n");
    fflush(_coverage_fout);
    }
    *(XYZ + 0) = tmp;
    {
    fprintf(_coverage_fout, "11042\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "11043\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11049\n");
  fflush(_coverage_fout);
  }
  Ce = (int )(p & 16383U);
  {
  fprintf(_coverage_fout, "11050\n");
  fflush(_coverage_fout);
  }
  tmp___1 = uv_decode(& u, & v, Ce);
  {
  fprintf(_coverage_fout, "11051\n");
  fflush(_coverage_fout);
  }
  if (tmp___1 < 0) {
    {
    fprintf(_coverage_fout, "11044\n");
    fflush(_coverage_fout);
    }
    u = 0.210526316;
    {
    fprintf(_coverage_fout, "11045\n");
    fflush(_coverage_fout);
    }
    v = 0.473684211;
  } else {
    {
    fprintf(_coverage_fout, "11046\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11052\n");
  fflush(_coverage_fout);
  }
  s = 1. / ((6. * u - 16. * v) + 12.);
  {
  fprintf(_coverage_fout, "11053\n");
  fflush(_coverage_fout);
  }
  x = (9. * u) * s;
  {
  fprintf(_coverage_fout, "11054\n");
  fflush(_coverage_fout);
  }
  y = (4. * v) * s;
  {
  fprintf(_coverage_fout, "11055\n");
  fflush(_coverage_fout);
  }
  *(XYZ + 0) = (float )((x / y) * L);
  {
  fprintf(_coverage_fout, "11056\n");
  fflush(_coverage_fout);
  }
  *(XYZ + 1) = (float )L;
  {
  fprintf(_coverage_fout, "11057\n");
  fflush(_coverage_fout);
  }
  *(XYZ + 2) = (float )((((1. - x) - y) / y) * L);
  {
  fprintf(_coverage_fout, "11058\n");
  fflush(_coverage_fout);
  }
  return;
}
}
uint32 LogLuv24fromXYZ(float *XYZ , int em ) 
{ int Le ;
  int Ce ;
  double u ;
  double v ;
  double s ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11068\n");
  fflush(_coverage_fout);
  }
  Le = LogL10fromY((double )*(XYZ + 1), em);
  {
  fprintf(_coverage_fout, "11069\n");
  fflush(_coverage_fout);
  }
  s = ((double )*(XYZ + 0) + 15. * (double )*(XYZ + 1)) + 3. * (double )*(XYZ + 2);
  {
  fprintf(_coverage_fout, "11070\n");
  fflush(_coverage_fout);
  }
  if (! Le) {
    {
    fprintf(_coverage_fout, "11059\n");
    fflush(_coverage_fout);
    }
    u = 0.210526316;
    {
    fprintf(_coverage_fout, "11060\n");
    fflush(_coverage_fout);
    }
    v = 0.473684211;
  } else {
    {
    fprintf(_coverage_fout, "11065\n");
    fflush(_coverage_fout);
    }
    if (s <= 0.) {
      {
      fprintf(_coverage_fout, "11061\n");
      fflush(_coverage_fout);
      }
      u = 0.210526316;
      {
      fprintf(_coverage_fout, "11062\n");
      fflush(_coverage_fout);
      }
      v = 0.473684211;
    } else {
      {
      fprintf(_coverage_fout, "11063\n");
      fflush(_coverage_fout);
      }
      u = (4. * (double )*(XYZ + 0)) / s;
      {
      fprintf(_coverage_fout, "11064\n");
      fflush(_coverage_fout);
      }
      v = (9. * (double )*(XYZ + 1)) / s;
    }
  }
  {
  fprintf(_coverage_fout, "11071\n");
  fflush(_coverage_fout);
  }
  Ce = uv_encode(u, v, em);
  {
  fprintf(_coverage_fout, "11072\n");
  fflush(_coverage_fout);
  }
  if (Ce < 0) {
    {
    fprintf(_coverage_fout, "11066\n");
    fflush(_coverage_fout);
    }
    Ce = uv_encode(0.210526316, 0.473684211, 0);
  } else {
    {
    fprintf(_coverage_fout, "11067\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11073\n");
  fflush(_coverage_fout);
  }
  return ((unsigned int )((Le << 14) | Ce));
}
}
static void Luv24toXYZ(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  float *xyz ;
  tmsize_t tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11081\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11082\n");
  fflush(_coverage_fout);
  }
  xyz = (float *)op;
  {
  fprintf(_coverage_fout, "11083\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11075\n");
    fflush(_coverage_fout);
    }
    tmp = n;
    {
    fprintf(_coverage_fout, "11076\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11077\n");
    fflush(_coverage_fout);
    }
    if (tmp > 0L) {
      {
      fprintf(_coverage_fout, "11074\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11078\n");
    fflush(_coverage_fout);
    }
    LogLuv24toXYZ(*luv, (float *)xyz);
    {
    fprintf(_coverage_fout, "11079\n");
    fflush(_coverage_fout);
    }
    xyz += 3;
    {
    fprintf(_coverage_fout, "11080\n");
    fflush(_coverage_fout);
    }
    luv ++;
  }
  {
  fprintf(_coverage_fout, "11084\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv24toLuv48(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  int16 *luv3 ;
  double u ;
  double v ;
  int16 *tmp ;
  int tmp___0 ;
  int16 *tmp___1 ;
  int16 *tmp___2 ;
  tmsize_t tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11104\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11105\n");
  fflush(_coverage_fout);
  }
  luv3 = (int16 *)op;
  {
  fprintf(_coverage_fout, "11106\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11089\n");
    fflush(_coverage_fout);
    }
    tmp___3 = n;
    {
    fprintf(_coverage_fout, "11090\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11091\n");
    fflush(_coverage_fout);
    }
    if (tmp___3 > 0L) {
      {
      fprintf(_coverage_fout, "11085\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11092\n");
    fflush(_coverage_fout);
    }
    tmp = luv3;
    {
    fprintf(_coverage_fout, "11093\n");
    fflush(_coverage_fout);
    }
    luv3 ++;
    {
    fprintf(_coverage_fout, "11094\n");
    fflush(_coverage_fout);
    }
    *tmp = (short )(((*luv >> 12) & 4093U) + 13314U);
    {
    fprintf(_coverage_fout, "11095\n");
    fflush(_coverage_fout);
    }
    tmp___0 = uv_decode(& u, & v, (int )(*luv & 16383U));
    {
    fprintf(_coverage_fout, "11096\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 < 0) {
      {
      fprintf(_coverage_fout, "11086\n");
      fflush(_coverage_fout);
      }
      u = 0.210526316;
      {
      fprintf(_coverage_fout, "11087\n");
      fflush(_coverage_fout);
      }
      v = 0.473684211;
    } else {
      {
      fprintf(_coverage_fout, "11088\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "11097\n");
    fflush(_coverage_fout);
    }
    tmp___1 = luv3;
    {
    fprintf(_coverage_fout, "11098\n");
    fflush(_coverage_fout);
    }
    luv3 ++;
    {
    fprintf(_coverage_fout, "11099\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = (short )(u * (double )(1L << 15));
    {
    fprintf(_coverage_fout, "11100\n");
    fflush(_coverage_fout);
    }
    tmp___2 = luv3;
    {
    fprintf(_coverage_fout, "11101\n");
    fflush(_coverage_fout);
    }
    luv3 ++;
    {
    fprintf(_coverage_fout, "11102\n");
    fflush(_coverage_fout);
    }
    *tmp___2 = (short )(v * (double )(1L << 15));
    {
    fprintf(_coverage_fout, "11103\n");
    fflush(_coverage_fout);
    }
    luv ++;
  }
  {
  fprintf(_coverage_fout, "11107\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv24toRGB(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  uint8 *rgb ;
  float xyz[3] ;
  uint32 *tmp ;
  tmsize_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11117\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11118\n");
  fflush(_coverage_fout);
  }
  rgb = op;
  {
  fprintf(_coverage_fout, "11119\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11109\n");
    fflush(_coverage_fout);
    }
    tmp___0 = n;
    {
    fprintf(_coverage_fout, "11110\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11111\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 0L) {
      {
      fprintf(_coverage_fout, "11108\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11112\n");
    fflush(_coverage_fout);
    }
    tmp = luv;
    {
    fprintf(_coverage_fout, "11113\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11114\n");
    fflush(_coverage_fout);
    }
    LogLuv24toXYZ(*tmp, (float *)(xyz));
    {
    fprintf(_coverage_fout, "11115\n");
    fflush(_coverage_fout);
    }
    XYZtoRGB24((float *)(xyz), (uint8 *)rgb);
    {
    fprintf(_coverage_fout, "11116\n");
    fflush(_coverage_fout);
    }
    rgb += 3;
  }
  {
  fprintf(_coverage_fout, "11120\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv24fromXYZ(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  float *xyz ;
  uint32 *tmp ;
  tmsize_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11129\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11130\n");
  fflush(_coverage_fout);
  }
  xyz = (float *)op;
  {
  fprintf(_coverage_fout, "11131\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11122\n");
    fflush(_coverage_fout);
    }
    tmp___0 = n;
    {
    fprintf(_coverage_fout, "11123\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11124\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 0L) {
      {
      fprintf(_coverage_fout, "11121\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11125\n");
    fflush(_coverage_fout);
    }
    tmp = luv;
    {
    fprintf(_coverage_fout, "11126\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11127\n");
    fflush(_coverage_fout);
    }
    *tmp = LogLuv24fromXYZ((float *)xyz, sp->encode_meth);
    {
    fprintf(_coverage_fout, "11128\n");
    fflush(_coverage_fout);
    }
    xyz += 3;
  }
  {
  fprintf(_coverage_fout, "11132\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv24fromLuv48(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  int16 *luv3 ;
  int Le ;
  int Ce ;
  int tmp ;
  uint32 *tmp___0 ;
  tmsize_t tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11155\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11156\n");
  fflush(_coverage_fout);
  }
  luv3 = (int16 *)op;
  {
  fprintf(_coverage_fout, "11157\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11145\n");
    fflush(_coverage_fout);
    }
    tmp___1 = n;
    {
    fprintf(_coverage_fout, "11146\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11147\n");
    fflush(_coverage_fout);
    }
    if (tmp___1 > 0L) {
      {
      fprintf(_coverage_fout, "11133\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11148\n");
    fflush(_coverage_fout);
    }
    if ((int )*(luv3 + 0) <= 0) {
      {
      fprintf(_coverage_fout, "11134\n");
      fflush(_coverage_fout);
      }
      Le = 0;
    } else {
      {
      fprintf(_coverage_fout, "11142\n");
      fflush(_coverage_fout);
      }
      if ((int )*(luv3 + 0) >= (1 << 12) + 3314) {
        {
        fprintf(_coverage_fout, "11135\n");
        fflush(_coverage_fout);
        }
        Le = (1 << 10) - 1;
      } else {
        {
        fprintf(_coverage_fout, "11141\n");
        fflush(_coverage_fout);
        }
        if (sp->encode_meth == 0) {
          {
          fprintf(_coverage_fout, "11136\n");
          fflush(_coverage_fout);
          }
          Le = ((int )*(luv3 + 0) - 3314) >> 2;
        } else {
          {
          fprintf(_coverage_fout, "11140\n");
          fflush(_coverage_fout);
          }
          if (sp->encode_meth == 0) {
            {
            fprintf(_coverage_fout, "11137\n");
            fflush(_coverage_fout);
            }
            Le = (int )(.25 * ((double )*(luv3 + 0) - 3314.));
          } else {
            {
            fprintf(_coverage_fout, "11138\n");
            fflush(_coverage_fout);
            }
            tmp = rand();
            {
            fprintf(_coverage_fout, "11139\n");
            fflush(_coverage_fout);
            }
            Le = (int )((.25 * ((double )*(luv3 + 0) - 3314.) + (double )tmp * (1. / (double )2147483647)) - .5);
          }
        }
      }
    }
    {
    fprintf(_coverage_fout, "11149\n");
    fflush(_coverage_fout);
    }
    Ce = uv_encode(((double )*(luv3 + 1) + .5) / (double )(1 << 15),
                   ((double )*(luv3 + 2) + .5) / (double )(1 << 15),
                   sp->encode_meth);
    {
    fprintf(_coverage_fout, "11150\n");
    fflush(_coverage_fout);
    }
    if (Ce < 0) {
      {
      fprintf(_coverage_fout, "11143\n");
      fflush(_coverage_fout);
      }
      Ce = uv_encode(0.210526316, 0.473684211, 0);
    } else {
      {
      fprintf(_coverage_fout, "11144\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "11151\n");
    fflush(_coverage_fout);
    }
    tmp___0 = luv;
    {
    fprintf(_coverage_fout, "11152\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11153\n");
    fflush(_coverage_fout);
    }
    *tmp___0 = ((unsigned int )Le << 14) | (unsigned int )Ce;
    {
    fprintf(_coverage_fout, "11154\n");
    fflush(_coverage_fout);
    }
    luv3 += 3;
  }
  {
  fprintf(_coverage_fout, "11158\n");
  fflush(_coverage_fout);
  }
  return;
}
}
void LogLuv32toXYZ(uint32 p , float *XYZ ) 
{ double L ;
  double u ;
  double v ;
  double s ;
  double x ;
  double y ;
  float tmp ;
  float tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11166\n");
  fflush(_coverage_fout);
  }
  L = LogL16toY((int )p >> 16);
  {
  fprintf(_coverage_fout, "11167\n");
  fflush(_coverage_fout);
  }
  if (L <= 0.) {
    {
    fprintf(_coverage_fout, "11159\n");
    fflush(_coverage_fout);
    }
    tmp___0 = (float )0.;
    {
    fprintf(_coverage_fout, "11160\n");
    fflush(_coverage_fout);
    }
    *(XYZ + 2) = tmp___0;
    {
    fprintf(_coverage_fout, "11161\n");
    fflush(_coverage_fout);
    }
    tmp = tmp___0;
    {
    fprintf(_coverage_fout, "11162\n");
    fflush(_coverage_fout);
    }
    *(XYZ + 1) = tmp;
    {
    fprintf(_coverage_fout, "11163\n");
    fflush(_coverage_fout);
    }
    *(XYZ + 0) = tmp;
    {
    fprintf(_coverage_fout, "11164\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "11165\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11168\n");
  fflush(_coverage_fout);
  }
  u = (1. / 410.) * ((double )((p >> 8) & 255U) + .5);
  {
  fprintf(_coverage_fout, "11169\n");
  fflush(_coverage_fout);
  }
  v = (1. / 410.) * ((double )(p & 255U) + .5);
  {
  fprintf(_coverage_fout, "11170\n");
  fflush(_coverage_fout);
  }
  s = 1. / ((6. * u - 16. * v) + 12.);
  {
  fprintf(_coverage_fout, "11171\n");
  fflush(_coverage_fout);
  }
  x = (9. * u) * s;
  {
  fprintf(_coverage_fout, "11172\n");
  fflush(_coverage_fout);
  }
  y = (4. * v) * s;
  {
  fprintf(_coverage_fout, "11173\n");
  fflush(_coverage_fout);
  }
  *(XYZ + 0) = (float )((x / y) * L);
  {
  fprintf(_coverage_fout, "11174\n");
  fflush(_coverage_fout);
  }
  *(XYZ + 1) = (float )L;
  {
  fprintf(_coverage_fout, "11175\n");
  fflush(_coverage_fout);
  }
  *(XYZ + 2) = (float )((((1. - x) - y) / y) * L);
  {
  fprintf(_coverage_fout, "11176\n");
  fflush(_coverage_fout);
  }
  return;
}
}
uint32 LogLuv32fromXYZ(float *XYZ , int em ) 
{ unsigned int Le ;
  unsigned int ue ;
  unsigned int ve ;
  double u ;
  double v ;
  double s ;
  int tmp ;
  int tmp___0 ;
  int tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11198\n");
  fflush(_coverage_fout);
  }
  tmp = LogL16fromY((double )*(XYZ + 1), em);
  {
  fprintf(_coverage_fout, "11199\n");
  fflush(_coverage_fout);
  }
  Le = (unsigned int )tmp;
  {
  fprintf(_coverage_fout, "11200\n");
  fflush(_coverage_fout);
  }
  s = ((double )*(XYZ + 0) + 15. * (double )*(XYZ + 1)) + 3. * (double )*(XYZ + 2);
  {
  fprintf(_coverage_fout, "11201\n");
  fflush(_coverage_fout);
  }
  if (! Le) {
    {
    fprintf(_coverage_fout, "11177\n");
    fflush(_coverage_fout);
    }
    u = 0.210526316;
    {
    fprintf(_coverage_fout, "11178\n");
    fflush(_coverage_fout);
    }
    v = 0.473684211;
  } else {
    {
    fprintf(_coverage_fout, "11183\n");
    fflush(_coverage_fout);
    }
    if (s <= 0.) {
      {
      fprintf(_coverage_fout, "11179\n");
      fflush(_coverage_fout);
      }
      u = 0.210526316;
      {
      fprintf(_coverage_fout, "11180\n");
      fflush(_coverage_fout);
      }
      v = 0.473684211;
    } else {
      {
      fprintf(_coverage_fout, "11181\n");
      fflush(_coverage_fout);
      }
      u = (4. * (double )*(XYZ + 0)) / s;
      {
      fprintf(_coverage_fout, "11182\n");
      fflush(_coverage_fout);
      }
      v = (9. * (double )*(XYZ + 1)) / s;
    }
  }
  {
  fprintf(_coverage_fout, "11202\n");
  fflush(_coverage_fout);
  }
  if (u <= 0.) {
    {
    fprintf(_coverage_fout, "11184\n");
    fflush(_coverage_fout);
    }
    ue = 0U;
  } else {
    {
    fprintf(_coverage_fout, "11188\n");
    fflush(_coverage_fout);
    }
    if (em == 0) {
      {
      fprintf(_coverage_fout, "11185\n");
      fflush(_coverage_fout);
      }
      ue = (unsigned int )((int )(410. * u));
    } else {
      {
      fprintf(_coverage_fout, "11186\n");
      fflush(_coverage_fout);
      }
      tmp___0 = rand();
      {
      fprintf(_coverage_fout, "11187\n");
      fflush(_coverage_fout);
      }
      ue = (unsigned int )((int )((410. * u + (double )tmp___0 * (1. / (double )2147483647)) - .5));
    }
  }
  {
  fprintf(_coverage_fout, "11203\n");
  fflush(_coverage_fout);
  }
  if (ue > 255U) {
    {
    fprintf(_coverage_fout, "11189\n");
    fflush(_coverage_fout);
    }
    ue = 255U;
  } else {
    {
    fprintf(_coverage_fout, "11190\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11204\n");
  fflush(_coverage_fout);
  }
  if (v <= 0.) {
    {
    fprintf(_coverage_fout, "11191\n");
    fflush(_coverage_fout);
    }
    ve = 0U;
  } else {
    {
    fprintf(_coverage_fout, "11195\n");
    fflush(_coverage_fout);
    }
    if (em == 0) {
      {
      fprintf(_coverage_fout, "11192\n");
      fflush(_coverage_fout);
      }
      ve = (unsigned int )((int )(410. * v));
    } else {
      {
      fprintf(_coverage_fout, "11193\n");
      fflush(_coverage_fout);
      }
      tmp___1 = rand();
      {
      fprintf(_coverage_fout, "11194\n");
      fflush(_coverage_fout);
      }
      ve = (unsigned int )((int )((410. * v + (double )tmp___1 * (1. / (double )2147483647)) - .5));
    }
  }
  {
  fprintf(_coverage_fout, "11205\n");
  fflush(_coverage_fout);
  }
  if (ve > 255U) {
    {
    fprintf(_coverage_fout, "11196\n");
    fflush(_coverage_fout);
    }
    ve = 255U;
  } else {
    {
    fprintf(_coverage_fout, "11197\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11206\n");
  fflush(_coverage_fout);
  }
  return (((Le << 16) | (ue << 8)) | ve);
}
}
static void Luv32toXYZ(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  float *xyz ;
  uint32 *tmp ;
  tmsize_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11215\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11216\n");
  fflush(_coverage_fout);
  }
  xyz = (float *)op;
  {
  fprintf(_coverage_fout, "11217\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11208\n");
    fflush(_coverage_fout);
    }
    tmp___0 = n;
    {
    fprintf(_coverage_fout, "11209\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11210\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 0L) {
      {
      fprintf(_coverage_fout, "11207\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11211\n");
    fflush(_coverage_fout);
    }
    tmp = luv;
    {
    fprintf(_coverage_fout, "11212\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11213\n");
    fflush(_coverage_fout);
    }
    LogLuv32toXYZ(*tmp, (float *)xyz);
    {
    fprintf(_coverage_fout, "11214\n");
    fflush(_coverage_fout);
    }
    xyz += 3;
  }
  {
  fprintf(_coverage_fout, "11218\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv32toLuv48(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  int16 *luv3 ;
  double u ;
  double v ;
  int16 *tmp ;
  int16 *tmp___0 ;
  int16 *tmp___1 ;
  tmsize_t tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11235\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11236\n");
  fflush(_coverage_fout);
  }
  luv3 = (int16 *)op;
  {
  fprintf(_coverage_fout, "11237\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11220\n");
    fflush(_coverage_fout);
    }
    tmp___2 = n;
    {
    fprintf(_coverage_fout, "11221\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11222\n");
    fflush(_coverage_fout);
    }
    if (tmp___2 > 0L) {
      {
      fprintf(_coverage_fout, "11219\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11223\n");
    fflush(_coverage_fout);
    }
    tmp = luv3;
    {
    fprintf(_coverage_fout, "11224\n");
    fflush(_coverage_fout);
    }
    luv3 ++;
    {
    fprintf(_coverage_fout, "11225\n");
    fflush(_coverage_fout);
    }
    *tmp = (short )(*luv >> 16);
    {
    fprintf(_coverage_fout, "11226\n");
    fflush(_coverage_fout);
    }
    u = (1. / 410.) * ((double )((*luv >> 8) & 255U) + .5);
    {
    fprintf(_coverage_fout, "11227\n");
    fflush(_coverage_fout);
    }
    v = (1. / 410.) * ((double )(*luv & 255U) + .5);
    {
    fprintf(_coverage_fout, "11228\n");
    fflush(_coverage_fout);
    }
    tmp___0 = luv3;
    {
    fprintf(_coverage_fout, "11229\n");
    fflush(_coverage_fout);
    }
    luv3 ++;
    {
    fprintf(_coverage_fout, "11230\n");
    fflush(_coverage_fout);
    }
    *tmp___0 = (short )(u * (double )(1L << 15));
    {
    fprintf(_coverage_fout, "11231\n");
    fflush(_coverage_fout);
    }
    tmp___1 = luv3;
    {
    fprintf(_coverage_fout, "11232\n");
    fflush(_coverage_fout);
    }
    luv3 ++;
    {
    fprintf(_coverage_fout, "11233\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = (short )(v * (double )(1L << 15));
    {
    fprintf(_coverage_fout, "11234\n");
    fflush(_coverage_fout);
    }
    luv ++;
  }
  {
  fprintf(_coverage_fout, "11238\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv32toRGB(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  uint8 *rgb ;
  float xyz[3] ;
  uint32 *tmp ;
  tmsize_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11248\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11249\n");
  fflush(_coverage_fout);
  }
  rgb = op;
  {
  fprintf(_coverage_fout, "11250\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11240\n");
    fflush(_coverage_fout);
    }
    tmp___0 = n;
    {
    fprintf(_coverage_fout, "11241\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11242\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 0L) {
      {
      fprintf(_coverage_fout, "11239\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11243\n");
    fflush(_coverage_fout);
    }
    tmp = luv;
    {
    fprintf(_coverage_fout, "11244\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11245\n");
    fflush(_coverage_fout);
    }
    LogLuv32toXYZ(*tmp, (float *)(xyz));
    {
    fprintf(_coverage_fout, "11246\n");
    fflush(_coverage_fout);
    }
    XYZtoRGB24((float *)(xyz), (uint8 *)rgb);
    {
    fprintf(_coverage_fout, "11247\n");
    fflush(_coverage_fout);
    }
    rgb += 3;
  }
  {
  fprintf(_coverage_fout, "11251\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv32fromXYZ(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  float *xyz ;
  uint32 *tmp ;
  tmsize_t tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11260\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11261\n");
  fflush(_coverage_fout);
  }
  xyz = (float *)op;
  {
  fprintf(_coverage_fout, "11262\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11253\n");
    fflush(_coverage_fout);
    }
    tmp___0 = n;
    {
    fprintf(_coverage_fout, "11254\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11255\n");
    fflush(_coverage_fout);
    }
    if (tmp___0 > 0L) {
      {
      fprintf(_coverage_fout, "11252\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11256\n");
    fflush(_coverage_fout);
    }
    tmp = luv;
    {
    fprintf(_coverage_fout, "11257\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11258\n");
    fflush(_coverage_fout);
    }
    *tmp = LogLuv32fromXYZ((float *)xyz, sp->encode_meth);
    {
    fprintf(_coverage_fout, "11259\n");
    fflush(_coverage_fout);
    }
    xyz += 3;
  }
  {
  fprintf(_coverage_fout, "11263\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void Luv32fromLuv48(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ uint32 *luv ;
  int16 *luv3 ;
  uint32 *tmp ;
  tmsize_t tmp___0 ;
  uint32 *tmp___1 ;
  int tmp___2 ;
  int tmp___3 ;
  int tmp___4 ;
  int tmp___5 ;
  tmsize_t tmp___6 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11291\n");
  fflush(_coverage_fout);
  }
  luv = (uint32 *)sp->tbuf;
  {
  fprintf(_coverage_fout, "11292\n");
  fflush(_coverage_fout);
  }
  luv3 = (int16 *)op;
  {
  fprintf(_coverage_fout, "11293\n");
  fflush(_coverage_fout);
  }
  if (sp->encode_meth == 0) {
    {
    fprintf(_coverage_fout, "11272\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "11265\n");
      fflush(_coverage_fout);
      }
      tmp___0 = n;
      {
      fprintf(_coverage_fout, "11266\n");
      fflush(_coverage_fout);
      }
      n --;
      {
      fprintf(_coverage_fout, "11267\n");
      fflush(_coverage_fout);
      }
      if (tmp___0 > 0L) {
        {
        fprintf(_coverage_fout, "11264\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "11268\n");
      fflush(_coverage_fout);
      }
      tmp = luv;
      {
      fprintf(_coverage_fout, "11269\n");
      fflush(_coverage_fout);
      }
      luv ++;
      {
      fprintf(_coverage_fout, "11270\n");
      fflush(_coverage_fout);
      }
      *tmp = (((unsigned int )*(luv3 + 0) << 16) | (((unsigned int )*(luv3 + 1) * (unsigned int )(410. + .5) >> 7) & 65280U)) | (((unsigned int )*(luv3 + 2) * (unsigned int )(410. + .5) >> 15) & 255U);
      {
      fprintf(_coverage_fout, "11271\n");
      fflush(_coverage_fout);
      }
      luv3 += 3;
    }
    {
    fprintf(_coverage_fout, "11273\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "11274\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11294\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "11282\n");
    fflush(_coverage_fout);
    }
    tmp___6 = n;
    {
    fprintf(_coverage_fout, "11283\n");
    fflush(_coverage_fout);
    }
    n --;
    {
    fprintf(_coverage_fout, "11284\n");
    fflush(_coverage_fout);
    }
    if (tmp___6 > 0L) {
      {
      fprintf(_coverage_fout, "11275\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "11285\n");
    fflush(_coverage_fout);
    }
    tmp___1 = luv;
    {
    fprintf(_coverage_fout, "11286\n");
    fflush(_coverage_fout);
    }
    luv ++;
    {
    fprintf(_coverage_fout, "11287\n");
    fflush(_coverage_fout);
    }
    if (sp->encode_meth == 0) {
      {
      fprintf(_coverage_fout, "11276\n");
      fflush(_coverage_fout);
      }
      tmp___3 = (int )((double )*(luv3 + 1) * (410. / (double )(1 << 15)));
    } else {
      {
      fprintf(_coverage_fout, "11277\n");
      fflush(_coverage_fout);
      }
      tmp___2 = rand();
      {
      fprintf(_coverage_fout, "11278\n");
      fflush(_coverage_fout);
      }
      tmp___3 = (int )(((double )*(luv3 + 1) * (410. / (double )(1 << 15)) + (double )tmp___2 * (1. / (double )2147483647)) - .5);
    }
    {
    fprintf(_coverage_fout, "11288\n");
    fflush(_coverage_fout);
    }
    if (sp->encode_meth == 0) {
      {
      fprintf(_coverage_fout, "11279\n");
      fflush(_coverage_fout);
      }
      tmp___5 = (int )((double )*(luv3 + 2) * (410. / (double )(1 << 15)));
    } else {
      {
      fprintf(_coverage_fout, "11280\n");
      fflush(_coverage_fout);
      }
      tmp___4 = rand();
      {
      fprintf(_coverage_fout, "11281\n");
      fflush(_coverage_fout);
      }
      tmp___5 = (int )(((double )*(luv3 + 2) * (410. / (double )(1 << 15)) + (double )tmp___4 * (1. / (double )2147483647)) - .5);
    }
    {
    fprintf(_coverage_fout, "11289\n");
    fflush(_coverage_fout);
    }
    *tmp___1 = (((unsigned int )*(luv3 + 0) << 16) | (unsigned int )((tmp___3 << 8) & 0xff00)) | (unsigned int )(tmp___5 & 0xff);
    {
    fprintf(_coverage_fout, "11290\n");
    fflush(_coverage_fout);
    }
    luv3 += 3;
  }
  {
  fprintf(_coverage_fout, "11295\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void _logLuvNop(LogLuvState *sp , uint8 *op , tmsize_t n ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11296\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static int LogL16GuessDataFmt(TIFFDirectory *td ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch ((((int )td->td_bitspersample << 6) | ((int )td->td_samplesperpixel << 3)) | (int )td->td_sampleformat) {
  {
  fprintf(_coverage_fout, "11297\n");
  fflush(_coverage_fout);
  }
  case ((32 << 6) | (1 << 3)) | 3: 
  return (0);
  {
  fprintf(_coverage_fout, "11298\n");
  fflush(_coverage_fout);
  }
  case ((16 << 6) | (1 << 3)) | 4: 
  case ((16 << 6) | (1 << 3)) | 2: 
  case ((16 << 6) | (1 << 3)) | 1: 
  return (1);
  {
  fprintf(_coverage_fout, "11299\n");
  fflush(_coverage_fout);
  }
  case ((8 << 6) | (1 << 3)) | 4: 
  case ((8 << 6) | (1 << 3)) | 1: 
  return (3);
  }
  {
  fprintf(_coverage_fout, "11300\n");
  fflush(_coverage_fout);
  }
  return (-1);
}
}
static tmsize_t multiply_ms(tmsize_t m1 , tmsize_t m2 ) 
{ tmsize_t bytes ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11305\n");
  fflush(_coverage_fout);
  }
  bytes = m1 * m2;
  {
  fprintf(_coverage_fout, "11306\n");
  fflush(_coverage_fout);
  }
  if (m1) {
    {
    fprintf(_coverage_fout, "11303\n");
    fflush(_coverage_fout);
    }
    if (bytes / m1 != m2) {
      {
      fprintf(_coverage_fout, "11301\n");
      fflush(_coverage_fout);
      }
      bytes = 0L;
    } else {
      {
      fprintf(_coverage_fout, "11302\n");
      fflush(_coverage_fout);
      }

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

  }
  {
  fprintf(_coverage_fout, "11307\n");
  fflush(_coverage_fout);
  }
  return (bytes);
}
}
static int LogL16InitState(TIFF *tif ) ;
static char const   module___2[16]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'1',      (char const   )'6',      (char const   )'I',      (char const   )'n', 
        (char const   )'i',      (char const   )'t',      (char const   )'S',      (char const   )'t', 
        (char const   )'a',      (char const   )'t',      (char const   )'e',      (char const   )'\000'};
static int LogL16InitState(TIFF *tif ) 
{ TIFFDirectory *td ;
  LogLuvState *sp ;
  tmsize_t tmp ;
  uint8 *tmp___0 ;
  void *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11328\n");
  fflush(_coverage_fout);
  }
  td = & tif->tif_dir;
  {
  fprintf(_coverage_fout, "11329\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "11330\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "11308\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11309\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 1205U, "LogL16InitState");
  }
  {
  fprintf(_coverage_fout, "11331\n");
  fflush(_coverage_fout);
  }
  if ((int )td->td_photometric == 32844) {
    {
    fprintf(_coverage_fout, "11310\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11311\n");
    fflush(_coverage_fout);
    }
    __assert_fail("td->td_photometric == 32844", "tif_luv.c", 1206U,
                  "LogL16InitState");
  }
  {
  fprintf(_coverage_fout, "11332\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == -1) {
    {
    fprintf(_coverage_fout, "11312\n");
    fflush(_coverage_fout);
    }
    sp->user_datafmt = LogL16GuessDataFmt(td);
  } else {
    {
    fprintf(_coverage_fout, "11313\n");
    fflush(_coverage_fout);
    }

  }
  switch (sp->user_datafmt) {
  {
  fprintf(_coverage_fout, "11314\n");
  fflush(_coverage_fout);
  }
  case 0: 
  sp->pixel_size = (int )sizeof(float );
  break;
  {
  fprintf(_coverage_fout, "11315\n");
  fflush(_coverage_fout);
  }
  case 1: 
  sp->pixel_size = (int )sizeof(int16 );
  break;
  {
  fprintf(_coverage_fout, "11316\n");
  fflush(_coverage_fout);
  }
  case 3: 
  sp->pixel_size = (int )sizeof(uint8 );
  break;
  {
  fprintf(_coverage_fout, "11317\n");
  fflush(_coverage_fout);
  }
  default: 
  TIFFErrorExt(tif->tif_clientdata, module___2,
               "No support for converting user data format to LogL");
  {
  fprintf(_coverage_fout, "11318\n");
  fflush(_coverage_fout);
  }
  return (0);
  }
  {
  fprintf(_coverage_fout, "11333\n");
  fflush(_coverage_fout);
  }
  sp->tbuflen = multiply_ms((long )td->td_imagewidth, (long )td->td_rowsperstrip);
  {
  fprintf(_coverage_fout, "11334\n");
  fflush(_coverage_fout);
  }
  tmp = multiply_ms(sp->tbuflen, (long )sizeof(int16 ));
  {
  fprintf(_coverage_fout, "11335\n");
  fflush(_coverage_fout);
  }
  if (tmp == 0L) {
    {
    fprintf(_coverage_fout, "11319\n");
    fflush(_coverage_fout);
    }
    TIFFErrorExt(tif->tif_clientdata, module___2,
                 "No space for SGILog translation buffer");
    {
    fprintf(_coverage_fout, "11320\n");
    fflush(_coverage_fout);
    }
    return (0);
  } else {
    {
    fprintf(_coverage_fout, "11324\n");
    fflush(_coverage_fout);
    }
    tmp___1 = _TIFFmalloc((long )((unsigned long )sp->tbuflen * (unsigned long )sizeof(int16 )));
    {
    fprintf(_coverage_fout, "11325\n");
    fflush(_coverage_fout);
    }
    tmp___0 = (uint8 *)tmp___1;
    {
    fprintf(_coverage_fout, "11326\n");
    fflush(_coverage_fout);
    }
    sp->tbuf = tmp___0;
    {
    fprintf(_coverage_fout, "11327\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )tmp___0 == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "11321\n");
      fflush(_coverage_fout);
      }
      TIFFErrorExt(tif->tif_clientdata, module___2,
                   "No space for SGILog translation buffer");
      {
      fprintf(_coverage_fout, "11322\n");
      fflush(_coverage_fout);
      }
      return (0);
    } else {
      {
      fprintf(_coverage_fout, "11323\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "11336\n");
  fflush(_coverage_fout);
  }
  return (1);
}
}
static int LogLuvGuessDataFmt(TIFFDirectory *td ) 
{ int guess ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch (((int )td->td_bitspersample << 3) | (int )td->td_sampleformat) {
  {
  fprintf(_coverage_fout, "11337\n");
  fflush(_coverage_fout);
  }
  case (32 << 3) | 3: 
  guess = 0;
  break;
  {
  fprintf(_coverage_fout, "11338\n");
  fflush(_coverage_fout);
  }
  case (32 << 3) | 4: 
  case (32 << 3) | 1: 
  case (32 << 3) | 2: 
  guess = 2;
  break;
  {
  fprintf(_coverage_fout, "11339\n");
  fflush(_coverage_fout);
  }
  case (16 << 3) | 4: 
  case (16 << 3) | 2: 
  case (16 << 3) | 1: 
  guess = 1;
  break;
  {
  fprintf(_coverage_fout, "11340\n");
  fflush(_coverage_fout);
  }
  case (8 << 3) | 4: 
  case (8 << 3) | 1: 
  guess = 3;
  break;
  {
  fprintf(_coverage_fout, "11341\n");
  fflush(_coverage_fout);
  }
  default: 
  guess = -1;
  break;
  }
  switch ((int )td->td_samplesperpixel) {
  {
  fprintf(_coverage_fout, "11346\n");
  fflush(_coverage_fout);
  }
  case 1: 
  if (guess != 2) {
    {
    fprintf(_coverage_fout, "11342\n");
    fflush(_coverage_fout);
    }
    guess = -1;
  } else {
    {
    fprintf(_coverage_fout, "11343\n");
    fflush(_coverage_fout);
    }

  }
  break;
  {
  fprintf(_coverage_fout, "11347\n");
  fflush(_coverage_fout);
  }
  case 3: 
  if (guess == 2) {
    {
    fprintf(_coverage_fout, "11344\n");
    fflush(_coverage_fout);
    }
    guess = -1;
  } else {
    {
    fprintf(_coverage_fout, "11345\n");
    fflush(_coverage_fout);
    }

  }
  break;
  {
  fprintf(_coverage_fout, "11348\n");
  fflush(_coverage_fout);
  }
  default: 
  guess = -1;
  break;
  }
  {
  fprintf(_coverage_fout, "11349\n");
  fflush(_coverage_fout);
  }
  return (guess);
}
}
static int LogLuvInitState(TIFF *tif ) ;
static char const   module___3[16]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'u',      (char const   )'v',      (char const   )'I',      (char const   )'n', 
        (char const   )'i',      (char const   )'t',      (char const   )'S',      (char const   )'t', 
        (char const   )'a',      (char const   )'t',      (char const   )'e',      (char const   )'\000'};
static int LogLuvInitState(TIFF *tif ) 
{ TIFFDirectory *td ;
  LogLuvState *sp ;
  tmsize_t tmp ;
  uint8 *tmp___0 ;
  void *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11374\n");
  fflush(_coverage_fout);
  }
  td = & tif->tif_dir;
  {
  fprintf(_coverage_fout, "11375\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "11376\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "11350\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11351\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != ((void *)0)", "tif_luv.c", 1294U, "LogLuvInitState");
  }
  {
  fprintf(_coverage_fout, "11377\n");
  fflush(_coverage_fout);
  }
  if ((int )td->td_photometric == 32845) {
    {
    fprintf(_coverage_fout, "11352\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11353\n");
    fflush(_coverage_fout);
    }
    __assert_fail("td->td_photometric == 32845", "tif_luv.c", 1295U,
                  "LogLuvInitState");
  }
  {
  fprintf(_coverage_fout, "11378\n");
  fflush(_coverage_fout);
  }
  if ((int )td->td_planarconfig != 1) {
    {
    fprintf(_coverage_fout, "11354\n");
    fflush(_coverage_fout);
    }
    TIFFErrorExt(tif->tif_clientdata, module___3,
                 "SGILog compression cannot handle non-contiguous data");
    {
    fprintf(_coverage_fout, "11355\n");
    fflush(_coverage_fout);
    }
    return (0);
  } else {
    {
    fprintf(_coverage_fout, "11356\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11379\n");
  fflush(_coverage_fout);
  }
  if (sp->user_datafmt == -1) {
    {
    fprintf(_coverage_fout, "11357\n");
    fflush(_coverage_fout);
    }
    sp->user_datafmt = LogLuvGuessDataFmt(td);
  } else {
    {
    fprintf(_coverage_fout, "11358\n");
    fflush(_coverage_fout);
    }

  }
  switch (sp->user_datafmt) {
  {
  fprintf(_coverage_fout, "11359\n");
  fflush(_coverage_fout);
  }
  case 0: 
  sp->pixel_size = (int )(3U * sizeof(float ));
  break;
  {
  fprintf(_coverage_fout, "11360\n");
  fflush(_coverage_fout);
  }
  case 1: 
  sp->pixel_size = (int )(3U * sizeof(int16 ));
  break;
  {
  fprintf(_coverage_fout, "11361\n");
  fflush(_coverage_fout);
  }
  case 2: 
  sp->pixel_size = (int )sizeof(uint32 );
  break;
  {
  fprintf(_coverage_fout, "11362\n");
  fflush(_coverage_fout);
  }
  case 3: 
  sp->pixel_size = (int )(3U * sizeof(uint8 ));
  break;
  {
  fprintf(_coverage_fout, "11363\n");
  fflush(_coverage_fout);
  }
  default: 
  TIFFErrorExt(tif->tif_clientdata, module___3,
               "No support for converting user data format to LogLuv");
  {
  fprintf(_coverage_fout, "11364\n");
  fflush(_coverage_fout);
  }
  return (0);
  }
  {
  fprintf(_coverage_fout, "11380\n");
  fflush(_coverage_fout);
  }
  sp->tbuflen = multiply_ms((long )td->td_imagewidth, (long )td->td_rowsperstrip);
  {
  fprintf(_coverage_fout, "11381\n");
  fflush(_coverage_fout);
  }
  tmp = multiply_ms(sp->tbuflen, (long )sizeof(uint32 ));
  {
  fprintf(_coverage_fout, "11382\n");
  fflush(_coverage_fout);
  }
  if (tmp == 0L) {
    {
    fprintf(_coverage_fout, "11365\n");
    fflush(_coverage_fout);
    }
    TIFFErrorExt(tif->tif_clientdata, module___3,
                 "No space for SGILog translation buffer");
    {
    fprintf(_coverage_fout, "11366\n");
    fflush(_coverage_fout);
    }
    return (0);
  } else {
    {
    fprintf(_coverage_fout, "11370\n");
    fflush(_coverage_fout);
    }
    tmp___1 = _TIFFmalloc((long )((unsigned long )sp->tbuflen * (unsigned long )sizeof(uint32 )));
    {
    fprintf(_coverage_fout, "11371\n");
    fflush(_coverage_fout);
    }
    tmp___0 = (uint8 *)tmp___1;
    {
    fprintf(_coverage_fout, "11372\n");
    fflush(_coverage_fout);
    }
    sp->tbuf = tmp___0;
    {
    fprintf(_coverage_fout, "11373\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )tmp___0 == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "11367\n");
      fflush(_coverage_fout);
      }
      TIFFErrorExt(tif->tif_clientdata, module___3,
                   "No space for SGILog translation buffer");
      {
      fprintf(_coverage_fout, "11368\n");
      fflush(_coverage_fout);
      }
      return (0);
    } else {
      {
      fprintf(_coverage_fout, "11369\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "11383\n");
  fflush(_coverage_fout);
  }
  return (1);
}
}
static int LogLuvFixupTags(TIFF *tif ) 
{ 

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11384\n");
  fflush(_coverage_fout);
  }
  return (1);
}
}
static int LogLuvSetupDecode(TIFF *tif ) ;
static char const   module___4[18]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'u',      (char const   )'v',      (char const   )'S',      (char const   )'e', 
        (char const   )'t',      (char const   )'u',      (char const   )'p',      (char const   )'D', 
        (char const   )'e',      (char const   )'c',      (char const   )'o',      (char const   )'d', 
        (char const   )'e',      (char const   )'\000'};
static int LogLuvSetupDecode(TIFF *tif ) 
{ LogLuvState *sp ;
  TIFFDirectory *td ;
  int tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11406\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "11407\n");
  fflush(_coverage_fout);
  }
  td = & tif->tif_dir;
  {
  fprintf(_coverage_fout, "11408\n");
  fflush(_coverage_fout);
  }
  tif->tif_postdecode = & _TIFFNoPostDecode;
  switch ((int )td->td_photometric) {
  {
  fprintf(_coverage_fout, "11397\n");
  fflush(_coverage_fout);
  }
  case 32845: 
  tmp = LogLuvInitState(tif);
  {
  fprintf(_coverage_fout, "11398\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "11385\n");
    fflush(_coverage_fout);
    }

  } else {
    break;
  }
  {
  fprintf(_coverage_fout, "11399\n");
  fflush(_coverage_fout);
  }
  if ((int )td->td_compression == 34677) {
    {
    fprintf(_coverage_fout, "11389\n");
    fflush(_coverage_fout);
    }
    tif->tif_decoderow = & LogLuvDecode24;
    switch (sp->user_datafmt) {
    {
    fprintf(_coverage_fout, "11386\n");
    fflush(_coverage_fout);
    }
    case 0: 
    sp->tfunc = & Luv24toXYZ;
    break;
    {
    fprintf(_coverage_fout, "11387\n");
    fflush(_coverage_fout);
    }
    case 1: 
    sp->tfunc = & Luv24toLuv48;
    break;
    {
    fprintf(_coverage_fout, "11388\n");
    fflush(_coverage_fout);
    }
    case 3: 
    sp->tfunc = & Luv24toRGB;
    break;
    }
  } else {
    {
    fprintf(_coverage_fout, "11393\n");
    fflush(_coverage_fout);
    }
    tif->tif_decoderow = & LogLuvDecode32;
    switch (sp->user_datafmt) {
    {
    fprintf(_coverage_fout, "11390\n");
    fflush(_coverage_fout);
    }
    case 0: 
    sp->tfunc = & Luv32toXYZ;
    break;
    {
    fprintf(_coverage_fout, "11391\n");
    fflush(_coverage_fout);
    }
    case 1: 
    sp->tfunc = & Luv32toLuv48;
    break;
    {
    fprintf(_coverage_fout, "11392\n");
    fflush(_coverage_fout);
    }
    case 3: 
    sp->tfunc = & Luv32toRGB;
    break;
    }
  }
  {
  fprintf(_coverage_fout, "11400\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11401\n");
  fflush(_coverage_fout);
  }
  case 32844: 
  tmp___0 = LogL16InitState(tif);
  {
  fprintf(_coverage_fout, "11402\n");
  fflush(_coverage_fout);
  }
  if (tmp___0) {
    {
    fprintf(_coverage_fout, "11394\n");
    fflush(_coverage_fout);
    }

  } else {
    break;
  }
  {
  fprintf(_coverage_fout, "11403\n");
  fflush(_coverage_fout);
  }
  tif->tif_decoderow = & LogL16Decode;
  switch (sp->user_datafmt) {
  {
  fprintf(_coverage_fout, "11395\n");
  fflush(_coverage_fout);
  }
  case 0: 
  sp->tfunc = & L16toY;
  break;
  {
  fprintf(_coverage_fout, "11396\n");
  fflush(_coverage_fout);
  }
  case 3: 
  sp->tfunc = & L16toGry;
  break;
  }
  {
  fprintf(_coverage_fout, "11404\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11405\n");
  fflush(_coverage_fout);
  }
  default: 
  TIFFErrorExt(tif->tif_clientdata, module___4,
               "Inappropriate photometric interpretation %d for SGILog compression; %s",
               td->td_photometric, "must be either LogLUV or LogL");
  break;
  }
  {
  fprintf(_coverage_fout, "11409\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int LogLuvSetupEncode(TIFF *tif ) ;
static char const   module___5[18]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'u',      (char const   )'v',      (char const   )'S',      (char const   )'e', 
        (char const   )'t',      (char const   )'u',      (char const   )'p',      (char const   )'E', 
        (char const   )'n',      (char const   )'c',      (char const   )'o',      (char const   )'d', 
        (char const   )'e',      (char const   )'\000'};
static int LogLuvSetupEncode(TIFF *tif ) 
{ LogLuvState *sp ;
  TIFFDirectory *td ;
  int tmp ;
  int tmp___0 ;
  char const   *tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11431\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "11432\n");
  fflush(_coverage_fout);
  }
  td = & tif->tif_dir;
  switch ((int )td->td_photometric) {
  {
  fprintf(_coverage_fout, "11422\n");
  fflush(_coverage_fout);
  }
  case 32845: 
  tmp = LogLuvInitState(tif);
  {
  fprintf(_coverage_fout, "11423\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "11410\n");
    fflush(_coverage_fout);
    }

  } else {
    break;
  }
  {
  fprintf(_coverage_fout, "11424\n");
  fflush(_coverage_fout);
  }
  if ((int )td->td_compression == 34677) {
    {
    fprintf(_coverage_fout, "11414\n");
    fflush(_coverage_fout);
    }
    tif->tif_encoderow = & LogLuvEncode24;
    switch (sp->user_datafmt) {
    {
    fprintf(_coverage_fout, "11411\n");
    fflush(_coverage_fout);
    }
    case 0: 
    sp->tfunc = & Luv24fromXYZ;
    break;
    {
    fprintf(_coverage_fout, "11412\n");
    fflush(_coverage_fout);
    }
    case 1: 
    sp->tfunc = & Luv24fromLuv48;
    break;
    case 2: 
    break;
    {
    fprintf(_coverage_fout, "11413\n");
    fflush(_coverage_fout);
    }
    default: ;
    goto notsupported;
    }
  } else {
    {
    fprintf(_coverage_fout, "11418\n");
    fflush(_coverage_fout);
    }
    tif->tif_encoderow = & LogLuvEncode32;
    switch (sp->user_datafmt) {
    {
    fprintf(_coverage_fout, "11415\n");
    fflush(_coverage_fout);
    }
    case 0: 
    sp->tfunc = & Luv32fromXYZ;
    break;
    {
    fprintf(_coverage_fout, "11416\n");
    fflush(_coverage_fout);
    }
    case 1: 
    sp->tfunc = & Luv32fromLuv48;
    break;
    case 2: 
    break;
    {
    fprintf(_coverage_fout, "11417\n");
    fflush(_coverage_fout);
    }
    default: ;
    goto notsupported;
    }
  }
  break;
  {
  fprintf(_coverage_fout, "11425\n");
  fflush(_coverage_fout);
  }
  case 32844: 
  tmp___0 = LogL16InitState(tif);
  {
  fprintf(_coverage_fout, "11426\n");
  fflush(_coverage_fout);
  }
  if (tmp___0) {
    {
    fprintf(_coverage_fout, "11419\n");
    fflush(_coverage_fout);
    }

  } else {
    break;
  }
  {
  fprintf(_coverage_fout, "11427\n");
  fflush(_coverage_fout);
  }
  tif->tif_encoderow = & LogL16Encode;
  switch (sp->user_datafmt) {
  {
  fprintf(_coverage_fout, "11420\n");
  fflush(_coverage_fout);
  }
  case 0: 
  sp->tfunc = & L16fromY;
  break;
  case 1: 
  break;
  {
  fprintf(_coverage_fout, "11421\n");
  fflush(_coverage_fout);
  }
  default: ;
  goto notsupported;
  }
  break;
  {
  fprintf(_coverage_fout, "11428\n");
  fflush(_coverage_fout);
  }
  default: 
  TIFFErrorExt(tif->tif_clientdata, module___5,
               "Inappropriate photometric interpretation %d for SGILog compression; %s",
               td->td_photometric, "must be either LogLUV or LogL");
  break;
  }
  {
  fprintf(_coverage_fout, "11433\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11434\n");
  fflush(_coverage_fout);
  }
  notsupported: 
  if ((int )td->td_photometric == 32844) {
    {
    fprintf(_coverage_fout, "11429\n");
    fflush(_coverage_fout);
    }
    tmp___1 = "Y, L";
  } else {
    {
    fprintf(_coverage_fout, "11430\n");
    fflush(_coverage_fout);
    }
    tmp___1 = "XYZ, Luv";
  }
  {
  fprintf(_coverage_fout, "11435\n");
  fflush(_coverage_fout);
  }
  TIFFErrorExt(tif->tif_clientdata, module___5,
               "SGILog compression supported only for %s, or raw data", tmp___1);
  {
  fprintf(_coverage_fout, "11436\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static void LogLuvClose(TIFF *tif ) 
{ TIFFDirectory *td ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11439\n");
  fflush(_coverage_fout);
  }
  td = & tif->tif_dir;
  {
  fprintf(_coverage_fout, "11440\n");
  fflush(_coverage_fout);
  }
  if ((int )td->td_photometric == 32844) {
    {
    fprintf(_coverage_fout, "11437\n");
    fflush(_coverage_fout);
    }
    td->td_samplesperpixel = (unsigned short)1;
  } else {
    {
    fprintf(_coverage_fout, "11438\n");
    fflush(_coverage_fout);
    }
    td->td_samplesperpixel = (unsigned short)3;
  }
  {
  fprintf(_coverage_fout, "11441\n");
  fflush(_coverage_fout);
  }
  td->td_bitspersample = (unsigned short)16;
  {
  fprintf(_coverage_fout, "11442\n");
  fflush(_coverage_fout);
  }
  td->td_sampleformat = (unsigned short)2;
  {
  fprintf(_coverage_fout, "11443\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static void LogLuvCleanup(TIFF *tif ) 
{ LogLuvState *sp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11448\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "11449\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )sp != (unsigned int )((LogLuvState *)0)) {
    {
    fprintf(_coverage_fout, "11444\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11445\n");
    fflush(_coverage_fout);
    }
    __assert_fail("sp != 0", "tif_luv.c", 1493U, "LogLuvCleanup");
  }
  {
  fprintf(_coverage_fout, "11450\n");
  fflush(_coverage_fout);
  }
  tif->tif_tagmethods.vgetfield = sp->vgetparent;
  {
  fprintf(_coverage_fout, "11451\n");
  fflush(_coverage_fout);
  }
  tif->tif_tagmethods.vsetfield = sp->vsetparent;
  {
  fprintf(_coverage_fout, "11452\n");
  fflush(_coverage_fout);
  }
  if (sp->tbuf) {
    {
    fprintf(_coverage_fout, "11446\n");
    fflush(_coverage_fout);
    }
    _TIFFfree((void *)sp->tbuf);
  } else {
    {
    fprintf(_coverage_fout, "11447\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11453\n");
  fflush(_coverage_fout);
  }
  _TIFFfree((void *)sp);
  {
  fprintf(_coverage_fout, "11454\n");
  fflush(_coverage_fout);
  }
  tif->tif_data = (uint8 *)((void *)0);
  {
  fprintf(_coverage_fout, "11455\n");
  fflush(_coverage_fout);
  }
  _TIFFSetDefaultCompressionState(tif);
  {
  fprintf(_coverage_fout, "11456\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static int LogLuvVSetField(TIFF *tif , uint32 tag , va_list ap ) ;
static char const   module___6[16]  = 
  {      (char const   )'L',      (char const   )'o',      (char const   )'g',      (char const   )'L', 
        (char const   )'u',      (char const   )'v',      (char const   )'V',      (char const   )'S', 
        (char const   )'e',      (char const   )'t',      (char const   )'F',      (char const   )'i', 
        (char const   )'e',      (char const   )'l',      (char const   )'d',      (char const   )'\000'};
static int LogLuvVSetField(TIFF *tif , uint32 tag , va_list ap ) 
{ LogLuvState *sp ;
  int bps ;
  int fmt ;
  int tmp ;
  tmsize_t tmp___0 ;
  int tmp___1 ;
  int tmp___2 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11489\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  switch ((int )tag) {
  {
  fprintf(_coverage_fout, "11476\n");
  fflush(_coverage_fout);
  }
  case 65560: 
  tmp = __builtin_va_arg(ap, int );
  {
  fprintf(_coverage_fout, "11477\n");
  fflush(_coverage_fout);
  }
  sp->user_datafmt = tmp;
  switch (sp->user_datafmt) {
  {
  fprintf(_coverage_fout, "11457\n");
  fflush(_coverage_fout);
  }
  case 0: 
  bps = 32;
  {
  fprintf(_coverage_fout, "11458\n");
  fflush(_coverage_fout);
  }
  fmt = 3;
  break;
  {
  fprintf(_coverage_fout, "11459\n");
  fflush(_coverage_fout);
  }
  case 1: 
  bps = 16;
  {
  fprintf(_coverage_fout, "11460\n");
  fflush(_coverage_fout);
  }
  fmt = 2;
  break;
  {
  fprintf(_coverage_fout, "11461\n");
  fflush(_coverage_fout);
  }
  case 2: 
  bps = 32;
  {
  fprintf(_coverage_fout, "11462\n");
  fflush(_coverage_fout);
  }
  fmt = 1;
  {
  fprintf(_coverage_fout, "11463\n");
  fflush(_coverage_fout);
  }
  TIFFSetField(tif, 277U, 1);
  break;
  {
  fprintf(_coverage_fout, "11464\n");
  fflush(_coverage_fout);
  }
  case 3: 
  bps = 8;
  {
  fprintf(_coverage_fout, "11465\n");
  fflush(_coverage_fout);
  }
  fmt = 1;
  break;
  {
  fprintf(_coverage_fout, "11466\n");
  fflush(_coverage_fout);
  }
  default: 
  TIFFErrorExt(tif->tif_clientdata, (char const   *)tif->tif_name,
               "Unknown data format %d for LogLuv compression", sp->user_datafmt);
  {
  fprintf(_coverage_fout, "11467\n");
  fflush(_coverage_fout);
  }
  return (0);
  }
  {
  fprintf(_coverage_fout, "11478\n");
  fflush(_coverage_fout);
  }
  TIFFSetField(tif, 258U, bps);
  {
  fprintf(_coverage_fout, "11479\n");
  fflush(_coverage_fout);
  }
  TIFFSetField(tif, 339U, fmt);
  {
  fprintf(_coverage_fout, "11480\n");
  fflush(_coverage_fout);
  }
  if ((tif->tif_flags & 1024U) != 0U) {
    {
    fprintf(_coverage_fout, "11468\n");
    fflush(_coverage_fout);
    }
    tmp___0 = TIFFTileSize(tif);
    {
    fprintf(_coverage_fout, "11469\n");
    fflush(_coverage_fout);
    }
    tif->tif_tilesize = tmp___0;
  } else {
    {
    fprintf(_coverage_fout, "11470\n");
    fflush(_coverage_fout);
    }
    tif->tif_tilesize = -1L;
  }
  {
  fprintf(_coverage_fout, "11481\n");
  fflush(_coverage_fout);
  }
  tif->tif_scanlinesize = TIFFScanlineSize(tif);
  {
  fprintf(_coverage_fout, "11482\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11483\n");
  fflush(_coverage_fout);
  }
  case 65561: 
  tmp___1 = __builtin_va_arg(ap, int );
  {
  fprintf(_coverage_fout, "11484\n");
  fflush(_coverage_fout);
  }
  sp->encode_meth = tmp___1;
  {
  fprintf(_coverage_fout, "11485\n");
  fflush(_coverage_fout);
  }
  if (sp->encode_meth != 0) {
    {
    fprintf(_coverage_fout, "11474\n");
    fflush(_coverage_fout);
    }
    if (sp->encode_meth != 1) {
      {
      fprintf(_coverage_fout, "11471\n");
      fflush(_coverage_fout);
      }
      TIFFErrorExt(tif->tif_clientdata, module___6,
                   "Unknown encoding %d for LogLuv compression", sp->encode_meth);
      {
      fprintf(_coverage_fout, "11472\n");
      fflush(_coverage_fout);
      }
      return (0);
    } else {
      {
      fprintf(_coverage_fout, "11473\n");
      fflush(_coverage_fout);
      }

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

  }
  {
  fprintf(_coverage_fout, "11486\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11487\n");
  fflush(_coverage_fout);
  }
  default: 
  tmp___2 = (*(sp->vsetparent))(tif, tag, ap);
  {
  fprintf(_coverage_fout, "11488\n");
  fflush(_coverage_fout);
  }
  return (tmp___2);
  }
}
}
static int LogLuvVGetField(TIFF *tif , uint32 tag , va_list ap ) 
{ LogLuvState *sp ;
  int *tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11495\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  switch ((int )tag) {
  {
  fprintf(_coverage_fout, "11490\n");
  fflush(_coverage_fout);
  }
  case 65560: 
  tmp = __builtin_va_arg(ap, int *);
  {
  fprintf(_coverage_fout, "11491\n");
  fflush(_coverage_fout);
  }
  *tmp = sp->user_datafmt;
  {
  fprintf(_coverage_fout, "11492\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11493\n");
  fflush(_coverage_fout);
  }
  default: 
  tmp___0 = (*(sp->vgetparent))(tif, tag, ap);
  {
  fprintf(_coverage_fout, "11494\n");
  fflush(_coverage_fout);
  }
  return (tmp___0);
  }
}
}
static TIFFField const   LogLuvFields[2]  = {      {(uint32 )65560, (short)0, (short)0, (TIFFDataType )3, (uint32 )0,
      (TIFFSetGetFieldType )8, (TIFFSetGetFieldType )0, (unsigned short)0,
      (unsigned char)1, (unsigned char)0, (char *)"SGILogDataFmt",
      (struct _TIFFFieldInfoArray  const  *)((void *)0)}, 
        {(uint32 )65561, (short)0, (short)0, (TIFFDataType )3, (uint32 )0,
      (TIFFSetGetFieldType )8, (TIFFSetGetFieldType )0, (unsigned short)0,
      (unsigned char)1, (unsigned char)0, (char *)"SGILogEncode",
      (struct _TIFFFieldInfoArray  const  *)((void *)0)}};
static char const   module___7[15]  = 
  {      (char const   )'T',      (char const   )'I',      (char const   )'F',      (char const   )'F', 
        (char const   )'I',      (char const   )'n',      (char const   )'i',      (char const   )'t', 
        (char const   )'S',      (char const   )'G',      (char const   )'I',      (char const   )'L', 
        (char const   )'o',      (char const   )'g',      (char const   )'\000'};
int TIFFInitSGILog(TIFF *tif , int scheme ) 
{ LogLuvState *sp ;
  int tmp ;
  void *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/libtiff-bug-2007-07-08-c766cb7-0cc95fb/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "11506\n");
  fflush(_coverage_fout);
  }
  if (scheme == 34677) {
    {
    fprintf(_coverage_fout, "11496\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11499\n");
    fflush(_coverage_fout);
    }
    if (scheme == 34676) {
      {
      fprintf(_coverage_fout, "11497\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "11498\n");
      fflush(_coverage_fout);
      }
      __assert_fail("scheme == 34677 || scheme == 34676", "tif_luv.c", 1590U,
                    "TIFFInitSGILog");
    }
  }
  {
  fprintf(_coverage_fout, "11507\n");
  fflush(_coverage_fout);
  }
  tmp = _TIFFMergeField(tif, LogLuvFields,
                        sizeof(LogLuvFields) / sizeof(LogLuvFields[0]));
  {
  fprintf(_coverage_fout, "11508\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "11500\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "11501\n");
    fflush(_coverage_fout);
    }
    TIFFErrorExt(tif->tif_clientdata, module___7,
                 "Merging SGILog codec-specific tags failed");
    {
    fprintf(_coverage_fout, "11502\n");
    fflush(_coverage_fout);
    }
    return (0);
  }
  {
  fprintf(_coverage_fout, "11509\n");
  fflush(_coverage_fout);
  }
  tmp___0 = _TIFFmalloc((long )sizeof(LogLuvState ));
  {
  fprintf(_coverage_fout, "11510\n");
  fflush(_coverage_fout);
  }
  tif->tif_data = (uint8 *)tmp___0;
  {
  fprintf(_coverage_fout, "11511\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )tif->tif_data == (unsigned int )((void *)0)) {
    goto bad;
  } else {
    {
    fprintf(_coverage_fout, "11503\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "11512\n");
  fflush(_coverage_fout);
  }
  sp = (LogLuvState *)tif->tif_data;
  {
  fprintf(_coverage_fout, "11513\n");
  fflush(_coverage_fout);
  }
  _TIFFmemset((void *)sp, 0, (long )sizeof(*sp));
  {
  fprintf(_coverage_fout, "11514\n");
  fflush(_coverage_fout);
  }
  sp->user_datafmt = -1;
  {
  fprintf(_coverage_fout, "11515\n");
  fflush(_coverage_fout);
  }
  if (scheme == 34677) {
    {
    fprintf(_coverage_fout, "11504\n");
    fflush(_coverage_fout);
    }
    sp->encode_meth = 1;
  } else {
    {
    fprintf(_coverage_fout, "11505\n");
    fflush(_coverage_fout);
    }
    sp->encode_meth = 0;
  }
  {
  fprintf(_coverage_fout, "11516\n");
  fflush(_coverage_fout);
  }
  sp->tfunc = & _logLuvNop;
  {
  fprintf(_coverage_fout, "11517\n");
  fflush(_coverage_fout);
  }
  tif->tif_fixuptags = & LogLuvFixupTags;
  {
  fprintf(_coverage_fout, "11518\n");
  fflush(_coverage_fout);
  }
  tif->tif_setupdecode = & LogLuvSetupDecode;
  {
  fprintf(_coverage_fout, "11519\n");
  fflush(_coverage_fout);
  }
  tif->tif_decodestrip = & LogLuvDecodeStrip;
  {
  fprintf(_coverage_fout, "11520\n");
  fflush(_coverage_fout);
  }
  tif->tif_decodetile = & LogLuvDecodeTile;
  {
  fprintf(_coverage_fout, "11521\n");
  fflush(_coverage_fout);
  }
  tif->tif_setupencode = & LogLuvSetupEncode;
  {
  fprintf(_coverage_fout, "11522\n");
  fflush(_coverage_fout);
  }
  tif->tif_encodestrip = & LogLuvEncodeStrip;
  {
  fprintf(_coverage_fout, "11523\n");
  fflush(_coverage_fout);
  }
  tif->tif_encodetile = & LogLuvEncodeTile;
  {
  fprintf(_coverage_fout, "11524\n");
  fflush(_coverage_fout);
  }
  tif->tif_close = & LogLuvClose;
  {
  fprintf(_coverage_fout, "11525\n");
  fflush(_coverage_fout);
  }
  tif->tif_cleanup = & LogLuvCleanup;
  {
  fprintf(_coverage_fout, "11526\n");
  fflush(_coverage_fout);
  }
  sp->vgetparent = tif->tif_tagmethods.vgetfield;
  {
  fprintf(_coverage_fout, "11527\n");
  fflush(_coverage_fout);
  }
  tif->tif_tagmethods.vgetfield = & LogLuvVGetField;
  {
  fprintf(_coverage_fout, "11528\n");
  fflush(_coverage_fout);
  }
  sp->vsetparent = tif->tif_tagmethods.vsetfield;
  {
  fprintf(_coverage_fout, "11529\n");
  fflush(_coverage_fout);
  }
  tif->tif_tagmethods.vsetfield = & LogLuvVSetField;
  {
  fprintf(_coverage_fout, "11530\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "11531\n");
  fflush(_coverage_fout);
  }
  bad: 
  TIFFErrorExt(tif->tif_clientdata, module___7,
               "%s: No space for LogLuv state block", tif->tif_name);
  {
  fprintf(_coverage_fout, "11532\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
