extern  __attribute__((__nothrow__)) void *( __attribute__((__nonnull__(1))) memset)(void *__s ,
                                                                                     int __c ,
                                                                                     unsigned int __n ) ;
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;
enum __anonenum_2 {
    _ISupper = 256,
    _ISlower = 512,
    _ISalpha = 1024,
    _ISdigit = 2048,
    _ISxdigit = 4096,
    _ISspace = 8192,
    _ISprint = 16384,
    _ISgraph = 32768,
    _ISblank = 1,
    _IScntrl = 2,
    _ISpunct = 4,
    _ISalnum = 8
} ;
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 BOOLEAN;
typedef char *string;
typedef unsigned int size_t;
typedef struct _IO_FILE FILE;
typedef struct _IO_FILE __FILE;
union __anonunion___value_4 {
   unsigned int __wch ;
   char __wchb[4] ;
};
struct __anonstruct___mbstate_t_3 {
   int __count ;
   union __anonunion___value_4 __value ;
};
typedef struct __anonstruct___mbstate_t_3 __mbstate_t;
struct __anonstruct__G_fpos_t_5 {
   __off_t __pos ;
   __mbstate_t __state ;
};
typedef struct __anonstruct__G_fpos_t_5 _G_fpos_t;
struct __anonstruct__G_fpos64_t_6 {
   __off64_t __pos ;
   __mbstate_t __state ;
};
typedef struct __anonstruct__G_fpos64_t_6 _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 __off_t off_t;
typedef __ssize_t ssize_t;
typedef _G_fpos_t fpos_t;
struct stream_type {
   FILE *fp ;
   int stream_ind ;
   char stream[80] ;
};
typedef struct stream_type *character_stream;
typedef char CHARACTER;
struct token_stream_type {
   character_stream ch_stream ;
};
typedef struct token_stream_type *token_stream;
struct token_type {
   int token_id ;
   char token_string[80] ;
};
typedef struct token_type *token;
extern  __attribute__((__nothrow__)) unsigned short const   **__ctype_b_loc(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) __int32_t const   **__ctype_tolower_loc(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) __int32_t const   **__ctype_toupper_loc(void)  __attribute__((__const__)) ;
extern  __attribute__((__nothrow__)) int isalnum(int  ) ;
extern  __attribute__((__nothrow__)) int isalpha(int  ) ;
extern  __attribute__((__nothrow__)) int iscntrl(int  ) ;
extern  __attribute__((__nothrow__)) int isdigit(int  ) ;
extern  __attribute__((__nothrow__)) int islower(int  ) ;
extern  __attribute__((__nothrow__)) int isgraph(int  ) ;
extern  __attribute__((__nothrow__)) int isprint(int  ) ;
extern  __attribute__((__nothrow__)) int ispunct(int  ) ;
extern  __attribute__((__nothrow__)) int isspace(int  ) ;
extern  __attribute__((__nothrow__)) int isupper(int  ) ;
extern  __attribute__((__nothrow__)) int isxdigit(int  ) ;
extern  __attribute__((__nothrow__)) int tolower(int __c ) ;
extern  __attribute__((__nothrow__)) int toupper(int __c ) ;
extern  __attribute__((__nothrow__)) int isblank(int  ) ;
extern  __attribute__((__nothrow__)) int isascii(int __c ) ;
extern  __attribute__((__nothrow__)) int toascii(int __c ) ;
extern  __attribute__((__nothrow__)) int _toupper(int  ) ;
extern  __attribute__((__nothrow__)) int _tolower(int  ) ;
extern  __attribute__((__nothrow__)) int isalnum_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isalpha_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int iscntrl_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isdigit_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int islower_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isgraph_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isprint_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int ispunct_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isspace_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isupper_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isxdigit_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int isblank_l(int  , __locale_t  ) ;
extern  __attribute__((__nothrow__)) int __tolower_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int tolower_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int __toupper_l(int __c , __locale_t __l ) ;
extern  __attribute__((__nothrow__)) int toupper_l(int __c , __locale_t __l ) ;
extern 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) ;
extern  __attribute__((__nothrow__)) char *tmpnam(char *__s ) ;
extern  __attribute__((__nothrow__)) char *tmpnam_r(char *__s ) ;
extern  __attribute__((__nothrow__)) char *tempnam(char const   *__dir ,
                                                   char const   *__pfx )  __attribute__((__malloc__)) ;
extern int fclose(FILE *__stream ) ;
extern int fflush(FILE *__stream ) ;
extern int fflush_unlocked(FILE *__stream ) ;
extern FILE *fopen(char const   * __restrict  __filename ,
                   char const   * __restrict  __modes ) ;
extern FILE *freopen(char const   * __restrict  __filename ,
                     char const   * __restrict  __modes ,
                     FILE * __restrict  __stream ) ;
extern  __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 fprintf(FILE * __restrict  __stream ,
                   char const   * __restrict  __format  , ...) ;
extern int printf(char const   * __restrict  __format  , ...) ;
extern  __attribute__((__nothrow__)) int sprintf(char * __restrict  __s ,
                                                 char const   * __restrict  __format 
                                                 , ...) ;
extern int vfprintf(FILE * __restrict  __s ,
                    char const   * __restrict  __format , __gnuc_va_list __arg ) ;
extern int vprintf(char const   * __restrict  __format , __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 ) ;
extern int getchar(void) ;
extern int getc_unlocked(FILE *__stream ) ;
extern int getchar_unlocked(void) ;
extern int fgetc_unlocked(FILE *__stream ) ;
extern int fputc(int __c , FILE *__stream ) ;
extern int putc(int __c , FILE *__stream ) ;
extern int putchar(int __c ) ;
extern int fputc_unlocked(int __c , FILE *__stream ) ;
extern int putc_unlocked(int __c , FILE *__stream ) ;
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 , __off_t __off , int __whence ) ;
extern __off_t ftello(FILE *__stream ) ;
extern int fgetpos(FILE * __restrict  __stream , fpos_t * __restrict  __pos ) ;
extern int fsetpos(FILE *__stream , fpos_t const   *__pos ) ;
extern  __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 ) ;
extern  __attribute__((__nothrow__)) int feof_unlocked(FILE *__stream ) ;
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 ) ;
character_stream open_character_stream(string FILENAME ) ;
CHARACTER get_char(character_stream stream_ptr ) ;
BOOLEAN is_end_of_character_stream(character_stream stream_ptr ) ;
token_stream open_token_stream(string FILENAME ) ;
token get_token(token_stream tstream_ptr ) ;
extern BOOLEAN compare_token() ;
BOOLEAN is_eof_token(token t ) ;
int default1[60]  = 
  {      54,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      51,      -2,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      52, 
        -3,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1};
int base[60]  = 
  {      -32,      -96,      -105,      -93, 
        -94,      -87,      -1,      -97, 
        -86,      -1,      -99,      -1, 
        -72,      -1,      -80,      -82, 
        -1,      53,      43,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      133,      -1, 
        233,      -1,      -1,      0, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      -1, 
        -1,      -1,      -1,      46, 
        40,      -1,      251,      -1, 
        -1,      -1,      -1,      -1};
int next[360]  = 
  {      0,      2,      26,      28, 
        3,      4,      5,      23, 
        19,      20,      6,      -1, 
        25,      8,      9,      11, 
        18,      18,      18,      18, 
        18,      18,      18,      18, 
        18,      18,      -1,      30, 
        -1,      31,      13,      15, 
        16,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      21, 
        -1,      22,      32,      -1, 
        24,      7,      17,      17, 
        17,      17,      17,      17, 
        17,      12,      17,      17, 
        1,      17,      17,      10, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        14,      17,      17,      18, 
        18,      18,      18,      18, 
        18,      18,      18,      18, 
        18,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      -1, 
        -1,      26,      26,      27, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        0,      0,      -1,      -1, 
        -1,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29, 
        29,      29,      29,      29};
int check[360]  = 
  {      0,      1,      0,      0, 
        2,      3,      4,      0, 
        0,      0,      5,      -1, 
        0,      7,      8,      10, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      -1,      0, 
        -1,      0,      12,      14, 
        15,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        -1,      0,      31,      -1, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      0, 
        0,      0,      0,      18, 
        18,      18,      18,      18, 
        18,      18,      18,      18, 
        18,      17,      17,      17, 
        17,      17,      17,      17, 
        17,      17,      17,      51, 
        51,      51,      51,      51, 
        51,      51,      51,      51, 
        51,      51,      51,      51, 
        51,      51,      51,      51, 
        51,      51,      51,      51, 
        51,      51,      51,      51, 
        51,      52,      52,      52, 
        52,      52,      52,      52, 
        52,      52,      52,      52, 
        52,      52,      52,      52, 
        52,      52,      52,      52, 
        52,      52,      52,      52, 
        52,      52,      52,      -1, 
        -1,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        26,      26,      26,      26, 
        54,      54,      -1,      -1, 
        -1,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28, 
        28,      28,      28,      28};
static token numeric_case(token_stream tstream_ptr , token token_ptr , char ch ,
                          char *token_str , int token_ind ) ;
static token error_or_eof_case(token_stream tstream_ptr , token token_ptr ,
                               int cu_state , char *token_str , int token_ind ,
                               char ch ) ;
static int check_delimiter(char ch ) ;
static int keyword(int state ) ;
static int special(int state ) ;
static int skip(character_stream stream_ptr ) ;
static int constant(int state , char *token_str , int token_ind ) ;
static int next_state(int state , char ch ) ;
static int get_actual_token(char *token_str , int token_ind ) ;
extern int ( /* missing proto */  exit)() ;
BOOLEAN print_token(token token_ptr ) ;
int main(int argc , char **argv ) 
{ 
  token token_ptr ;
  token_stream stream_ptr ;
  BOOLEAN tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "9\n");
  fflush(_coverage_fout);
  }
  if (argc > 2) {
    {
    fprintf(_coverage_fout, "1\n");
    fflush(_coverage_fout);
    }
    fprintf((FILE */* __restrict  */)stdout,
            (char const   */* __restrict  */)"The format is print_tokens filename(optional)\n");
    {
    fprintf(_coverage_fout, "2\n");
    fflush(_coverage_fout);
    }
    exit(1);
  } else {
    {
    fprintf(_coverage_fout, "3\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "10\n");
  fflush(_coverage_fout);
  }
  stream_ptr = open_token_stream(*(argv + 1));
  {
  fprintf(_coverage_fout, "11\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "5\n");
    fflush(_coverage_fout);
    }
    token_ptr = get_token(stream_ptr);
    {
    fprintf(_coverage_fout, "6\n");
    fflush(_coverage_fout);
    }
    tmp = is_eof_token(token_ptr);
    {
    fprintf(_coverage_fout, "7\n");
    fflush(_coverage_fout);
    }
    if (tmp) {
      break;
    } else {
      {
      fprintf(_coverage_fout, "4\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "8\n");
    fflush(_coverage_fout);
    }
    print_token(token_ptr);
  }
  {
  fprintf(_coverage_fout, "12\n");
  fflush(_coverage_fout);
  }
  print_token(token_ptr);
  {
  fprintf(_coverage_fout, "13\n");
  fflush(_coverage_fout);
  }
  exit(0);
}
}
extern int ( /* missing proto */  malloc)() ;
character_stream open_character_stream(string FILENAME ) 
{ 
  character_stream stream_ptr ;
  int tmp ;
  FILE *tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "21\n");
  fflush(_coverage_fout);
  }
  tmp = malloc(sizeof(struct stream_type ));
  {
  fprintf(_coverage_fout, "22\n");
  fflush(_coverage_fout);
  }
  stream_ptr = (character_stream )tmp;
  {
  fprintf(_coverage_fout, "23\n");
  fflush(_coverage_fout);
  }
  stream_ptr->stream_ind = 5;
  {
  fprintf(_coverage_fout, "24\n");
  fflush(_coverage_fout);
  }
  stream_ptr->stream[5] = (char )'\000';
  {
  fprintf(_coverage_fout, "25\n");
  fflush(_coverage_fout);
  }
  if ((unsigned int )FILENAME == (unsigned int )((void *)0)) {
    {
    fprintf(_coverage_fout, "14\n");
    fflush(_coverage_fout);
    }
    stream_ptr->fp = stdin;
  } else {
    {
    fprintf(_coverage_fout, "18\n");
    fflush(_coverage_fout);
    }
    tmp___0 = fopen((char const   */* __restrict  */)FILENAME,
                    (char const   */* __restrict  */)"r");
    {
    fprintf(_coverage_fout, "19\n");
    fflush(_coverage_fout);
    }
    stream_ptr->fp = tmp___0;
    {
    fprintf(_coverage_fout, "20\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )tmp___0 == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "15\n");
      fflush(_coverage_fout);
      }
      fprintf((FILE */* __restrict  */)stdout,
              (char const   */* __restrict  */)"The file %s doesn\'t exists\n",
              FILENAME);
      {
      fprintf(_coverage_fout, "16\n");
      fflush(_coverage_fout);
      }
      exit(0);
    } else {
      {
      fprintf(_coverage_fout, "17\n");
      fflush(_coverage_fout);
      }

    }
  }
  {
  fprintf(_coverage_fout, "26\n");
  fflush(_coverage_fout);
  }
  return (stream_ptr);
}
}
CHARACTER get_char(character_stream stream_ptr ) 
{ 
  char *tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "33\n");
  fflush(_coverage_fout);
  }
  if ((int )stream_ptr->stream[stream_ptr->stream_ind] == 0) {
    {
    fprintf(_coverage_fout, "29\n");
    fflush(_coverage_fout);
    }
    tmp = fgets((char */* __restrict  */)(stream_ptr->stream + 5), 75,
                (FILE */* __restrict  */)stream_ptr->fp);
    {
    fprintf(_coverage_fout, "30\n");
    fflush(_coverage_fout);
    }
    if ((unsigned int )tmp == (unsigned int )((void *)0)) {
      {
      fprintf(_coverage_fout, "27\n");
      fflush(_coverage_fout);
      }
      stream_ptr->stream[5] = (char)-1;
    } else {
      {
      fprintf(_coverage_fout, "28\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "31\n");
    fflush(_coverage_fout);
    }
    stream_ptr->stream_ind = 5;
  } else {
    {
    fprintf(_coverage_fout, "32\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "34\n");
  fflush(_coverage_fout);
  }
  tmp___0 = stream_ptr->stream_ind;
  {
  fprintf(_coverage_fout, "35\n");
  fflush(_coverage_fout);
  }
  (stream_ptr->stream_ind) ++;
  {
  fprintf(_coverage_fout, "36\n");
  fflush(_coverage_fout);
  }
  return (stream_ptr->stream[tmp___0]);
}
}
BOOLEAN is_end_of_character_stream(character_stream stream_ptr ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "39\n");
  fflush(_coverage_fout);
  }
  if ((int )stream_ptr->stream[stream_ptr->stream_ind - 1] == -1) {
    {
    fprintf(_coverage_fout, "37\n");
    fflush(_coverage_fout);
    }
    return (1);
  } else {
    {
    fprintf(_coverage_fout, "38\n");
    fflush(_coverage_fout);
    }
    return (0);
  }
}
}
int unget_char(CHARACTER ch , character_stream stream_ptr ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "43\n");
  fflush(_coverage_fout);
  }
  if (stream_ptr->stream_ind == 0) {
    {
    fprintf(_coverage_fout, "40\n");
    fflush(_coverage_fout);
    }
    return;
  } else {
    {
    fprintf(_coverage_fout, "41\n");
    fflush(_coverage_fout);
    }
    (stream_ptr->stream_ind) --;
    {
    fprintf(_coverage_fout, "42\n");
    fflush(_coverage_fout);
    }
    stream_ptr->stream[stream_ptr->stream_ind] = ch;
  }
  {
  fprintf(_coverage_fout, "44\n");
  fflush(_coverage_fout);
  }
  return;
}
}
token_stream open_token_stream(string FILENAME ) 
{ 
  token_stream token_ptr ;
  int tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "45\n");
  fflush(_coverage_fout);
  }
  tmp = malloc(sizeof(struct token_stream_type ));
  {
  fprintf(_coverage_fout, "46\n");
  fflush(_coverage_fout);
  }
  token_ptr = (token_stream )tmp;
  {
  fprintf(_coverage_fout, "47\n");
  fflush(_coverage_fout);
  }
  token_ptr->ch_stream = open_character_stream(FILENAME);
  {
  fprintf(_coverage_fout, "48\n");
  fflush(_coverage_fout);
  }
  return (token_ptr);
}
}
extern int ( /* missing proto */  strcpy)() ;
token get_token(token_stream tstream_ptr ) 
{ 
  char token_str[80] ;
  int token_ind ;
  token token_ptr ;
  CHARACTER ch ;
  int cu_state ;
  int next_st ;
  int token_found ;
  int tmp ;
  int tmp___0 ;
  token tmp___1 ;
  token tmp___2 ;
  int tmp___3 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "92\n");
  fflush(_coverage_fout);
  }
  tmp = malloc(sizeof(struct token_type ));
  {
  fprintf(_coverage_fout, "93\n");
  fflush(_coverage_fout);
  }
  token_ptr = (token )tmp;
  {
  fprintf(_coverage_fout, "94\n");
  fflush(_coverage_fout);
  }
  ch = get_char(tstream_ptr->ch_stream);
  {
  fprintf(_coverage_fout, "95\n");
  fflush(_coverage_fout);
  }
  token_found = 0;
  {
  fprintf(_coverage_fout, "96\n");
  fflush(_coverage_fout);
  }
  token_ind = token_found;
  {
  fprintf(_coverage_fout, "97\n");
  fflush(_coverage_fout);
  }
  cu_state = token_ind;
  {
  fprintf(_coverage_fout, "98\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "87\n");
    fflush(_coverage_fout);
    }
    if (! token_found) {
      {
      fprintf(_coverage_fout, "49\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "88\n");
    fflush(_coverage_fout);
    }
    if (token_ind < 80) {
      {
      fprintf(_coverage_fout, "50\n");
      fflush(_coverage_fout);
      }
      tmp___0 = token_ind;
      {
      fprintf(_coverage_fout, "51\n");
      fflush(_coverage_fout);
      }
      token_ind ++;
      {
      fprintf(_coverage_fout, "52\n");
      fflush(_coverage_fout);
      }
      token_str[tmp___0] = ch;
      {
      fprintf(_coverage_fout, "53\n");
      fflush(_coverage_fout);
      }
      next_st = next_state(cu_state, ch);
    } else {
      {
      fprintf(_coverage_fout, "54\n");
      fflush(_coverage_fout);
      }
      next_st = -1;
    }
    {
    fprintf(_coverage_fout, "89\n");
    fflush(_coverage_fout);
    }
    if (next_st == -1) {
      {
      fprintf(_coverage_fout, "55\n");
      fflush(_coverage_fout);
      }
      tmp___1 = error_or_eof_case(tstream_ptr, token_ptr, cu_state, token_str,
                                  token_ind, ch);
      {
      fprintf(_coverage_fout, "56\n");
      fflush(_coverage_fout);
      }
      return (tmp___1);
    } else {
      {
      fprintf(_coverage_fout, "67\n");
      fflush(_coverage_fout);
      }
      if (next_st == -2) {
        {
        fprintf(_coverage_fout, "57\n");
        fflush(_coverage_fout);
        }
        tmp___2 = numeric_case(tstream_ptr, token_ptr, ch, token_str, token_ind);
        {
        fprintf(_coverage_fout, "58\n");
        fflush(_coverage_fout);
        }
        return (tmp___2);
      } else {
        {
        fprintf(_coverage_fout, "66\n");
        fflush(_coverage_fout);
        }
        if (next_st == -3) {
          {
          fprintf(_coverage_fout, "59\n");
          fflush(_coverage_fout);
          }
          token_ptr->token_id = 17;
          {
          fprintf(_coverage_fout, "60\n");
          fflush(_coverage_fout);
          }
          unget_char(ch, tstream_ptr->ch_stream);
          {
          fprintf(_coverage_fout, "61\n");
          fflush(_coverage_fout);
          }
          token_ind --;
          {
          fprintf(_coverage_fout, "62\n");
          fflush(_coverage_fout);
          }
          get_actual_token(token_str, token_ind);
          {
          fprintf(_coverage_fout, "63\n");
          fflush(_coverage_fout);
          }
          strcpy(token_ptr->token_string, token_str);
          {
          fprintf(_coverage_fout, "64\n");
          fflush(_coverage_fout);
          }
          return (token_ptr);
        } else {
          {
          fprintf(_coverage_fout, "65\n");
          fflush(_coverage_fout);
          }

        }
      }
    }
    switch (next_st) {
    default: 
    break;
    {
    fprintf(_coverage_fout, "73\n");
    fflush(_coverage_fout);
    }
    case 16: 
    case 12: 
    case 13: 
    case 11: 
    case 9: 
    case 6: 
    ch = get_char(tstream_ptr->ch_stream);
    {
    fprintf(_coverage_fout, "74\n");
    fflush(_coverage_fout);
    }
    tmp___3 = check_delimiter(ch);
    {
    fprintf(_coverage_fout, "75\n");
    fflush(_coverage_fout);
    }
    if (tmp___3 == 1) {
      {
      fprintf(_coverage_fout, "68\n");
      fflush(_coverage_fout);
      }
      token_ptr->token_id = keyword(next_st);
      {
      fprintf(_coverage_fout, "69\n");
      fflush(_coverage_fout);
      }
      unget_char(ch, tstream_ptr->ch_stream);
      {
      fprintf(_coverage_fout, "70\n");
      fflush(_coverage_fout);
      }
      token_ptr->token_string[0] = (char )'\000';
      {
      fprintf(_coverage_fout, "71\n");
      fflush(_coverage_fout);
      }
      return (token_ptr);
    } else {
      {
      fprintf(_coverage_fout, "72\n");
      fflush(_coverage_fout);
      }

    }
    {
    fprintf(_coverage_fout, "76\n");
    fflush(_coverage_fout);
    }
    unget_char(ch, tstream_ptr->ch_stream);
    break;
    {
    fprintf(_coverage_fout, "77\n");
    fflush(_coverage_fout);
    }
    case 32: 
    case 25: 
    case 24: 
    case 23: 
    case 22: 
    case 21: 
    case 20: 
    case 19: 
    token_ptr->token_id = special(next_st);
    {
    fprintf(_coverage_fout, "78\n");
    fflush(_coverage_fout);
    }
    token_ptr->token_string[0] = (char )'\000';
    {
    fprintf(_coverage_fout, "79\n");
    fflush(_coverage_fout);
    }
    return (token_ptr);
    {
    fprintf(_coverage_fout, "80\n");
    fflush(_coverage_fout);
    }
    case 29: 
    case 27: 
    token_ptr->token_id = constant(next_st, token_str, token_ind);
    {
    fprintf(_coverage_fout, "81\n");
    fflush(_coverage_fout);
    }
    get_actual_token(token_str, token_ind);
    {
    fprintf(_coverage_fout, "82\n");
    fflush(_coverage_fout);
    }
    strcpy(token_ptr->token_string, token_str);
    {
    fprintf(_coverage_fout, "83\n");
    fflush(_coverage_fout);
    }
    return (token_ptr);
    {
    fprintf(_coverage_fout, "84\n");
    fflush(_coverage_fout);
    }
    case 30: 
    skip(tstream_ptr->ch_stream);
    {
    fprintf(_coverage_fout, "85\n");
    fflush(_coverage_fout);
    }
    next_st = 0;
    {
    fprintf(_coverage_fout, "86\n");
    fflush(_coverage_fout);
    }
    token_ind = next_st;
    break;
    }
    {
    fprintf(_coverage_fout, "90\n");
    fflush(_coverage_fout);
    }
    cu_state = next_st;
    {
    fprintf(_coverage_fout, "91\n");
    fflush(_coverage_fout);
    }
    ch = get_char(tstream_ptr->ch_stream);
  }
  {
  fprintf(_coverage_fout, "99\n");
  fflush(_coverage_fout);
  }
  return ((struct token_type *)0);
}
}
static token numeric_case(token_stream tstream_ptr , token token_ptr , char ch ,
                          char *token_str , int token_ind ) 
{ 
  int tmp ;
  int tmp___0 ;
  int tmp___1 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "117\n");
  fflush(_coverage_fout);
  }
  tmp___1 = check_delimiter(ch);
  {
  fprintf(_coverage_fout, "118\n");
  fflush(_coverage_fout);
  }
  if (tmp___1 != 1) {
    {
    fprintf(_coverage_fout, "109\n");
    fflush(_coverage_fout);
    }
    token_ptr->token_id = -1;
    {
    fprintf(_coverage_fout, "110\n");
    fflush(_coverage_fout);
    }
    while (1) {
      {
      fprintf(_coverage_fout, "102\n");
      fflush(_coverage_fout);
      }
      tmp___0 = check_delimiter(ch);
      {
      fprintf(_coverage_fout, "103\n");
      fflush(_coverage_fout);
      }
      if (tmp___0 == 0) {
        {
        fprintf(_coverage_fout, "100\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
      {
      fprintf(_coverage_fout, "104\n");
      fflush(_coverage_fout);
      }
      if (token_ind >= 80) {
        break;
      } else {
        {
        fprintf(_coverage_fout, "101\n");
        fflush(_coverage_fout);
        }

      }
      {
      fprintf(_coverage_fout, "105\n");
      fflush(_coverage_fout);
      }
      tmp = token_ind;
      {
      fprintf(_coverage_fout, "106\n");
      fflush(_coverage_fout);
      }
      token_ind ++;
      {
      fprintf(_coverage_fout, "107\n");
      fflush(_coverage_fout);
      }
      ch = get_char(tstream_ptr->ch_stream);
      {
      fprintf(_coverage_fout, "108\n");
      fflush(_coverage_fout);
      }
      *(token_str + tmp) = ch;
    }
    {
    fprintf(_coverage_fout, "111\n");
    fflush(_coverage_fout);
    }
    unget_char(ch, tstream_ptr->ch_stream);
    {
    fprintf(_coverage_fout, "112\n");
    fflush(_coverage_fout);
    }
    token_ind --;
    {
    fprintf(_coverage_fout, "113\n");
    fflush(_coverage_fout);
    }
    get_actual_token(token_str, token_ind);
    {
    fprintf(_coverage_fout, "114\n");
    fflush(_coverage_fout);
    }
    strcpy(token_ptr->token_string, token_str);
    {
    fprintf(_coverage_fout, "115\n");
    fflush(_coverage_fout);
    }
    return (token_ptr);
  } else {
    {
    fprintf(_coverage_fout, "116\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "119\n");
  fflush(_coverage_fout);
  }
  token_ptr->token_id = 18;
  {
  fprintf(_coverage_fout, "120\n");
  fflush(_coverage_fout);
  }
  unget_char(ch, tstream_ptr->ch_stream);
  {
  fprintf(_coverage_fout, "121\n");
  fflush(_coverage_fout);
  }
  token_ind --;
  {
  fprintf(_coverage_fout, "122\n");
  fflush(_coverage_fout);
  }
  get_actual_token(token_str, token_ind);
  {
  fprintf(_coverage_fout, "123\n");
  fflush(_coverage_fout);
  }
  strcpy(token_ptr->token_string, token_str);
  {
  fprintf(_coverage_fout, "124\n");
  fflush(_coverage_fout);
  }
  return (token_ptr);
}
}
static token error_or_eof_case(token_stream tstream_ptr , token token_ptr ,
                               int cu_state , char *token_str , int token_ind ,
                               char ch ) 
{ 
  BOOLEAN tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "132\n");
  fflush(_coverage_fout);
  }
  tmp = is_end_of_character_stream(tstream_ptr->ch_stream);
  {
  fprintf(_coverage_fout, "133\n");
  fflush(_coverage_fout);
  }
  if (tmp) {
    {
    fprintf(_coverage_fout, "125\n");
    fflush(_coverage_fout);
    }
    token_ptr->token_id = 0;
    {
    fprintf(_coverage_fout, "126\n");
    fflush(_coverage_fout);
    }
    token_ptr->token_string[0] = (char )'\000';
    {
    fprintf(_coverage_fout, "127\n");
    fflush(_coverage_fout);
    }
    return (token_ptr);
  } else {
    {
    fprintf(_coverage_fout, "128\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "134\n");
  fflush(_coverage_fout);
  }
  if (cu_state != 0) {
    {
    fprintf(_coverage_fout, "129\n");
    fflush(_coverage_fout);
    }
    unget_char(ch, tstream_ptr->ch_stream);
    {
    fprintf(_coverage_fout, "130\n");
    fflush(_coverage_fout);
    }
    token_ind --;
  } else {
    {
    fprintf(_coverage_fout, "131\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "135\n");
  fflush(_coverage_fout);
  }
  token_ptr->token_id = -1;
  {
  fprintf(_coverage_fout, "136\n");
  fflush(_coverage_fout);
  }
  get_actual_token(token_str, token_ind);
  {
  fprintf(_coverage_fout, "137\n");
  fflush(_coverage_fout);
  }
  strcpy(token_ptr->token_string, token_str);
  {
  fprintf(_coverage_fout, "138\n");
  fflush(_coverage_fout);
  }
  return (token_ptr);
}
}
static int check_delimiter(char ch ) 
{ 
  unsigned short const   **tmp ;
  unsigned short const   **tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "144\n");
  fflush(_coverage_fout);
  }
  tmp = __ctype_b_loc();
  {
  fprintf(_coverage_fout, "145\n");
  fflush(_coverage_fout);
  }
  if ((int const   )*(*tmp + (int )ch) & 1024) {
    {
    fprintf(_coverage_fout, "139\n");
    fflush(_coverage_fout);
    }

  } else {
    {
    fprintf(_coverage_fout, "142\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __ctype_b_loc();
    {
    fprintf(_coverage_fout, "143\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(*tmp___0 + (int )ch) & 2048) {
      {
      fprintf(_coverage_fout, "140\n");
      fflush(_coverage_fout);
      }

    } else {
      {
      fprintf(_coverage_fout, "141\n");
      fflush(_coverage_fout);
      }
      return (1);
    }
  }
  {
  fprintf(_coverage_fout, "146\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int keyword(int state ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch (state) {
  {
  fprintf(_coverage_fout, "147\n");
  fflush(_coverage_fout);
  }
  case 6: 
  return (6);
  {
  fprintf(_coverage_fout, "148\n");
  fflush(_coverage_fout);
  }
  case 9: 
  return (9);
  {
  fprintf(_coverage_fout, "149\n");
  fflush(_coverage_fout);
  }
  case 11: 
  return (11);
  {
  fprintf(_coverage_fout, "150\n");
  fflush(_coverage_fout);
  }
  case 13: 
  return (13);
  {
  fprintf(_coverage_fout, "151\n");
  fflush(_coverage_fout);
  }
  case 16: 
  return (16);
  {
  fprintf(_coverage_fout, "152\n");
  fflush(_coverage_fout);
  }
  default: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"error\n");
  break;
  }
  {
  fprintf(_coverage_fout, "153\n");
  fflush(_coverage_fout);
  }
  exit(0);
}
}
static int special(int state ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch (state) {
  {
  fprintf(_coverage_fout, "154\n");
  fflush(_coverage_fout);
  }
  case 19: 
  return (19);
  {
  fprintf(_coverage_fout, "155\n");
  fflush(_coverage_fout);
  }
  case 20: 
  return (20);
  {
  fprintf(_coverage_fout, "156\n");
  fflush(_coverage_fout);
  }
  case 21: 
  return (21);
  {
  fprintf(_coverage_fout, "157\n");
  fflush(_coverage_fout);
  }
  case 22: 
  return (22);
  {
  fprintf(_coverage_fout, "158\n");
  fflush(_coverage_fout);
  }
  case 23: 
  return (23);
  {
  fprintf(_coverage_fout, "159\n");
  fflush(_coverage_fout);
  }
  case 24: 
  return (24);
  {
  fprintf(_coverage_fout, "160\n");
  fflush(_coverage_fout);
  }
  case 25: 
  return (25);
  {
  fprintf(_coverage_fout, "161\n");
  fflush(_coverage_fout);
  }
  case 32: 
  return (32);
  {
  fprintf(_coverage_fout, "162\n");
  fflush(_coverage_fout);
  }
  default: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"error\n");
  break;
  }
  {
  fprintf(_coverage_fout, "163\n");
  fflush(_coverage_fout);
  }
  exit(0);
}
}
static int skip(character_stream stream_ptr ) 
{ 
  char c ;
  BOOLEAN tmp ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "171\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "167\n");
    fflush(_coverage_fout);
    }
    c = get_char(stream_ptr);
    {
    fprintf(_coverage_fout, "168\n");
    fflush(_coverage_fout);
    }
    if ((int )c != 10) {
      {
      fprintf(_coverage_fout, "165\n");
      fflush(_coverage_fout);
      }
      tmp = is_end_of_character_stream(stream_ptr);
      {
      fprintf(_coverage_fout, "166\n");
      fflush(_coverage_fout);
      }
      if (tmp) {
        break;
      } else {
        {
        fprintf(_coverage_fout, "164\n");
        fflush(_coverage_fout);
        }

      }
    } else {
      break;
    }
  }
  {
  fprintf(_coverage_fout, "172\n");
  fflush(_coverage_fout);
  }
  if ((int )c == -1) {
    {
    fprintf(_coverage_fout, "169\n");
    fflush(_coverage_fout);
    }
    unget_char(c, stream_ptr);
  } else {
    {
    fprintf(_coverage_fout, "170\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "173\n");
  fflush(_coverage_fout);
  }
  return;
}
}
static int constant(int state , char *token_str , int token_ind ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch (state) {
  {
  fprintf(_coverage_fout, "174\n");
  fflush(_coverage_fout);
  }
  case 27: 
  return (27);
  {
  fprintf(_coverage_fout, "175\n");
  fflush(_coverage_fout);
  }
  case 29: 
  *(token_str + (token_ind - 2)) = (char )' ';
  {
  fprintf(_coverage_fout, "176\n");
  fflush(_coverage_fout);
  }
  return (29);
  default: 
  break;
  }
  {
  fprintf(_coverage_fout, "177\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int next_state(int state , char ch ) 
{ 
  int tmp ;
  int tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "186\n");
  fflush(_coverage_fout);
  }
  if (state < 0) {
    {
    fprintf(_coverage_fout, "178\n");
    fflush(_coverage_fout);
    }
    return (state);
  } else {
    {
    fprintf(_coverage_fout, "179\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "187\n");
  fflush(_coverage_fout);
  }
  if (base[state] + (int )ch >= 0) {
    {
    fprintf(_coverage_fout, "183\n");
    fflush(_coverage_fout);
    }
    if (check[base[state] + (int )ch] == state) {
      {
      fprintf(_coverage_fout, "180\n");
      fflush(_coverage_fout);
      }
      return (next[base[state] + (int )ch]);
    } else {
      {
      fprintf(_coverage_fout, "181\n");
      fflush(_coverage_fout);
      }
      tmp = next_state(default1[state], ch);
      {
      fprintf(_coverage_fout, "182\n");
      fflush(_coverage_fout);
      }
      return (tmp);
    }
  } else {
    {
    fprintf(_coverage_fout, "184\n");
    fflush(_coverage_fout);
    }
    tmp___0 = next_state(default1[state], ch);
    {
    fprintf(_coverage_fout, "185\n");
    fflush(_coverage_fout);
    }
    return (tmp___0);
  }
}
}
BOOLEAN is_eof_token(token t ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "190\n");
  fflush(_coverage_fout);
  }
  if (t->token_id == 0) {
    {
    fprintf(_coverage_fout, "188\n");
    fflush(_coverage_fout);
    }
    return (1);
  } else {
    {
    fprintf(_coverage_fout, "189\n");
    fflush(_coverage_fout);
    }

  }
  {
  fprintf(_coverage_fout, "191\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
BOOLEAN print_token(token token_ptr ) 
{ 


  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  switch (token_ptr->token_id) {
  {
  fprintf(_coverage_fout, "192\n");
  fflush(_coverage_fout);
  }
  case -1: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"error,\t\"");
  {
  fprintf(_coverage_fout, "193\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"%s", token_ptr->token_string);
  {
  fprintf(_coverage_fout, "194\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"\".\n");
  {
  fprintf(_coverage_fout, "195\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "196\n");
  fflush(_coverage_fout);
  }
  case 0: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"eof.\n");
  {
  fprintf(_coverage_fout, "197\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "198\n");
  fflush(_coverage_fout);
  }
  case 6: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"keyword,\t\"lambda\".\n");
  {
  fprintf(_coverage_fout, "199\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "200\n");
  fflush(_coverage_fout);
  }
  case 9: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"keyword,\t\"and\".\n");
  {
  fprintf(_coverage_fout, "201\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "202\n");
  fflush(_coverage_fout);
  }
  case 11: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"keyword,\t\"or\".\n");
  {
  fprintf(_coverage_fout, "203\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "204\n");
  fflush(_coverage_fout);
  }
  case 13: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"keyword,\t\"if\".\n");
  {
  fprintf(_coverage_fout, "205\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "206\n");
  fflush(_coverage_fout);
  }
  case 16: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"keyword,\t\"xor\".\n");
  {
  fprintf(_coverage_fout, "207\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "208\n");
  fflush(_coverage_fout);
  }
  case 17: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"identifier,\t\"");
  {
  fprintf(_coverage_fout, "209\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"%s", token_ptr->token_string);
  {
  fprintf(_coverage_fout, "210\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"\".\n");
  {
  fprintf(_coverage_fout, "211\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "212\n");
  fflush(_coverage_fout);
  }
  case 18: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"numeric,\t");
  {
  fprintf(_coverage_fout, "213\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"%s", token_ptr->token_string);
  {
  fprintf(_coverage_fout, "214\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)".\n");
  {
  fprintf(_coverage_fout, "215\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "216\n");
  fflush(_coverage_fout);
  }
  case 19: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"lparen.\n");
  {
  fprintf(_coverage_fout, "217\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "218\n");
  fflush(_coverage_fout);
  }
  case 20: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"rparen.\n");
  {
  fprintf(_coverage_fout, "219\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "220\n");
  fflush(_coverage_fout);
  }
  case 21: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"lsquare.\n");
  {
  fprintf(_coverage_fout, "221\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "222\n");
  fflush(_coverage_fout);
  }
  case 22: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"rsquare.\n");
  {
  fprintf(_coverage_fout, "223\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "224\n");
  fflush(_coverage_fout);
  }
  case 23: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"quote.\n");
  {
  fprintf(_coverage_fout, "225\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "226\n");
  fflush(_coverage_fout);
  }
  case 24: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"bquote.\n");
  {
  fprintf(_coverage_fout, "227\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "228\n");
  fflush(_coverage_fout);
  }
  case 25: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"comma.\n");
  {
  fprintf(_coverage_fout, "229\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "230\n");
  fflush(_coverage_fout);
  }
  case 27: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"string,\t");
  {
  fprintf(_coverage_fout, "231\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"%s", token_ptr->token_string);
  {
  fprintf(_coverage_fout, "232\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)".\n");
  {
  fprintf(_coverage_fout, "233\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "234\n");
  fflush(_coverage_fout);
  }
  case 29: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"character,\t\"");
  {
  fprintf(_coverage_fout, "235\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"%s", token_ptr->token_string);
  {
  fprintf(_coverage_fout, "236\n");
  fflush(_coverage_fout);
  }
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"\".\n");
  {
  fprintf(_coverage_fout, "237\n");
  fflush(_coverage_fout);
  }
  return (1);
  {
  fprintf(_coverage_fout, "238\n");
  fflush(_coverage_fout);
  }
  case 32: 
  fprintf((FILE */* __restrict  */)stdout,
          (char const   */* __restrict  */)"keyword,\t\"=>\".\n");
  {
  fprintf(_coverage_fout, "239\n");
  fflush(_coverage_fout);
  }
  return (1);
  default: 
  break;
  }
  {
  fprintf(_coverage_fout, "240\n");
  fflush(_coverage_fout);
  }
  return (0);
}
}
static int get_actual_token(char *token_str , int token_ind ) 
{ 
  int ind ;
  int start ;
  unsigned short const   **tmp ;
  unsigned short const   **tmp___0 ;

  {
  {
  if (_coverage_fout == 0) {
    {
    _coverage_fout = fopen("/root/mountpoint-genprog/genprog-many-bugs/print_tokens-v2/coverage/coverage.path",
                           "wb");
    }
  }
  }
  {
  fprintf(_coverage_fout, "257\n");
  fflush(_coverage_fout);
  }
  ind = token_ind;
  {
  fprintf(_coverage_fout, "258\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "244\n");
    fflush(_coverage_fout);
    }
    if (ind > 0) {
      {
      fprintf(_coverage_fout, "242\n");
      fflush(_coverage_fout);
      }
      tmp = __ctype_b_loc();
      {
      fprintf(_coverage_fout, "243\n");
      fflush(_coverage_fout);
      }
      if ((int const   )*(*tmp + (int )*(token_str + (ind - 1))) & 8192) {
        {
        fprintf(_coverage_fout, "241\n");
        fflush(_coverage_fout);
        }

      } else {
        break;
      }
    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "245\n");
    fflush(_coverage_fout);
    }
    ind --;
  }
  {
  fprintf(_coverage_fout, "259\n");
  fflush(_coverage_fout);
  }
  *(token_str + ind) = (char )'\000';
  {
  fprintf(_coverage_fout, "260\n");
  fflush(_coverage_fout);
  }
  token_ind = ind;
  {
  fprintf(_coverage_fout, "261\n");
  fflush(_coverage_fout);
  }
  ind = 0;
  {
  fprintf(_coverage_fout, "262\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "248\n");
    fflush(_coverage_fout);
    }
    if (ind < token_ind) {
      {
      fprintf(_coverage_fout, "246\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "249\n");
    fflush(_coverage_fout);
    }
    tmp___0 = __ctype_b_loc();
    {
    fprintf(_coverage_fout, "250\n");
    fflush(_coverage_fout);
    }
    if ((int const   )*(*tmp___0 + (int )*(token_str + ind)) & 8192) {
      {
      fprintf(_coverage_fout, "247\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "251\n");
    fflush(_coverage_fout);
    }
    ind ++;
  }
  {
  fprintf(_coverage_fout, "263\n");
  fflush(_coverage_fout);
  }
  start = 0;
  {
  fprintf(_coverage_fout, "264\n");
  fflush(_coverage_fout);
  }
  while (1) {
    {
    fprintf(_coverage_fout, "253\n");
    fflush(_coverage_fout);
    }
    if (ind <= token_ind) {
      {
      fprintf(_coverage_fout, "252\n");
      fflush(_coverage_fout);
      }

    } else {
      break;
    }
    {
    fprintf(_coverage_fout, "254\n");
    fflush(_coverage_fout);
    }
    *(token_str + start) = *(token_str + ind);
    {
    fprintf(_coverage_fout, "255\n");
    fflush(_coverage_fout);
    }
    start ++;
    {
    fprintf(_coverage_fout, "256\n");
    fflush(_coverage_fout);
    }
    ind ++;
  }
  {
  fprintf(_coverage_fout, "265\n");
  fflush(_coverage_fout);
  }
  return;
}
}
