/* A lexical scanner generated by flex */

/* Scanner skeleton version:
 * $Header: /a1/cvsadm/cvsroot/expsir/csubjects/flex/versions.alt/versions.orig/v0/flex.c,v 1.1.1.1 2003/06/02 17:12:00 expsir Exp $
 */

#define FLEX_SCANNER

#include <stdio.h>


/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif


#ifdef __cplusplus

#include <stdlib.h>
#include <unistd.h>

/* Use prototypes in function declarations. */
#define YY_USE_PROTOS

/* The "const" storage-class-modifier is valid. */
#define YY_USE_CONST

#else	/* ! __cplusplus */

#ifdef __STDC__

#define YY_USE_PROTOS
#define YY_USE_CONST

#endif	/* __STDC__ */
#endif	/* ! __cplusplus */


#ifdef __TURBOC__
#define YY_USE_CONST
#endif


#ifndef YY_USE_CONST
#ifndef const
#define const
#endif
#endif


#ifdef YY_USE_PROTOS
#define YY_PROTO(proto) proto
#else
#define YY_PROTO(proto) ()
#endif

/* Returned upon end-of-file. */
#define YY_NULL 0

/* Enter a start condition.  This macro really ought to take a parameter,
 * but we do it the disgusting crufty way forced on us by the ()-less
 * definition of BEGIN.
 */
#define BEGIN yy_start = 1 + 2 *

/* Translate the current start state into a value that can be later handed
 * to BEGIN to return to the state.
 */
#define YY_START ((yy_start - 1) / 2)

/* Action number for EOF rule of a given start state. */
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)

/* Special action meaning "start processing a new file".  Now included
 * only for backward compatibility with previous versions of flex.
 */
#define YY_NEW_FILE yyrestart( yyin )

#define YY_END_OF_BUFFER_CHAR 0

/* Size of default input buffer. */
#define YY_BUF_SIZE 16384

typedef struct yy_buffer_state *YY_BUFFER_STATE;

extern int yyleng;
extern FILE *yyin, *yyout;

#ifdef __cplusplus
extern "C" {
#endif
	extern void *yy_flex_alloc YY_PROTO(( int ));
	extern void *yy_flex_realloc YY_PROTO(( void *ptr, int size ));
	extern void yy_flex_free YY_PROTO(( void * ));
	extern int yywrap YY_PROTO(( void ));
	extern void yy_strcpy YY_PROTO(( char *s1, const char *s2 ));
#ifdef __cplusplus
	}
#endif

#define EOB_ACT_CONTINUE_SCAN 0
#define EOB_ACT_END_OF_FILE 1
#define EOB_ACT_LAST_MATCH 2

/* The funky do-while in the following #define is used to turn the definition
 * int a single C statement (which needs a semi-colon terminator).  This
 * avoids problems with code like:
 *
 * 	if ( condition_holds )
 *		yyless( 5 );
 *	else
 *		do_something_else();
 *
 * Prior to using the do-while the compiler would get upset at the
 * "else" because it interpreted the "if" statement as being all
 * done when it reached the ';' after the yyless() call.
 */

/* Return all but the first 'n' matched characters back to the input stream. */

#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
		*yy_cp = yy_hold_char; \
		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
		} \
	while ( 0 )

#define unput(c) yyunput( c, yytext_ptr )


struct yy_buffer_state
	{
	FILE *yy_input_file;

	char *yy_ch_buf;		/* input buffer */
	char *yy_buf_pos;		/* current position in input buffer */

	/* Size of input buffer in bytes, not including room for EOB
	 * characters.
	 */
	int yy_buf_size;

	/* Number of characters read into yy_ch_buf, not including EOB
	 * characters.
	 */
	int yy_n_chars;

	/* Whether this is an "interactive" input source; if so, and
	 * if we're using stdio for input, then we want to use getc()
	 * instead of fread(), to make sure we stop fetching input after
	 * each newline.
	 */
	int is_interactive;

	/* Whether we've seen an EOF on this buffer. */
	int yy_eof_status;
#define EOF_NOT_SEEN 0
	/* "Pending" happens when the EOF has been seen but there's still
	 * some text to process.  Note that when we actually see the EOF,
	 * we switch the status back to "not seen" (via yyrestart()), so
	 * that the user can continue scanning by just pointing yyin at
	 * a new input file.
	 */
#define EOF_PENDING 1
	};

static YY_BUFFER_STATE yy_current_buffer = 0;

/* We provide macros for accessing buffer states in case in the
 * future we want to put the buffer states in a more general
 * "scanner state".
 */
#define YY_CURRENT_BUFFER yy_current_buffer


/* yy_hold_char holds the character lost when yytext is formed. */
static char yy_hold_char;

static int yy_n_chars;		/* number of characters read into yy_ch_buf */


int yyleng;

/* Points to current character in buffer. */
static char *yy_c_buf_p = (char *) 0;
static int yy_init = 1;		/* whether we need to initialize */
static int yy_start = 0;	/* start state number */

/* Flag which is used to allow yywrap()'s to do buffer switches
 * instead of setting up a fresh yyin.  A bit of a hack ...
 */
static int yy_did_buffer_switch_on_eof;

static void yyunput YY_PROTO(( int c, char *buf_ptr ));
void yyrestart YY_PROTO(( FILE *input_file ));
void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
void yy_load_buffer_state YY_PROTO(( void ));
YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));

#define yy_new_buffer yy_create_buffer

#define INITIAL 0
typedef unsigned char YY_CHAR;
typedef const struct yy_trans_info *yy_state_type;
FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
extern char *yytext;
#define yytext_ptr yytext

#ifdef __cplusplus
static int yyinput YY_PROTO(( void ));
#else
static int input YY_PROTO(( void ));
#endif

static yy_state_type yy_get_previous_state YY_PROTO(( void ));
static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
static int yy_get_next_buffer YY_PROTO(( void ));
static void yy_fatal_error YY_PROTO(( const char msg[] ));

/* Done after the current pattern has been matched and before the
 * corresponding action - sets up yytext.
 */
#define YY_DO_BEFORE_ACTION \
	yytext_ptr = yy_bp; \
	yyleng = yy_cp - yy_bp; \
	yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yy_c_buf_p = yy_cp;

#define YY_END_OF_BUFFER 10
struct yy_trans_info
	{
	short yy_verify;
	short yy_nxt;
	};
static const struct yy_trans_info yy_transition[893] =
    {
      0,     0,      0,   867,      0,     1,      0,   865,      1,    56,
      2,    58,      3,    63,      4,    68,      5,    68,      6,    68,
      7,    56,      8,    68,      9,    70,     10,    72,     11,    98,
     12,    72,     13,    72,     14,   124,     15,   150,     16,    72,
     17,    72,     18,   176,     19,    72,     20,    72,     21,   202,
     22,    72,     23,   228,     24,    72,     25,   254,     26,    56,
      0,     1,      0,   837,      1,    28,      2,    30,      3,    35,
      4,    40,      5,    40,      6,    40,      7,    28,      8,    40,
      9,    42,     10,    44,     11,    70,     12,    44,     13,    44,
     14,    96,     15,   122,     16,    44,     17,    44,     18,   148,

     19,    44,     20,    44,     21,   174,     22,    44,     23,   200,
     24,    44,     25,   226,     26,    28,      0,     8,      0,   809,
      0,     7,      0,   807,      0,     0,      2,    42,      3,    42,
      0,     7,      0,   802,      0,     0,      2,    37,      3,    37,
      0,     5,      0,   797,      0,     1,      0,   795,      0,     4,
      0,   793,      0,     0,      0,     0,      0,     0,      0,     0,
      7,   212,      0,     0,      9,   215,      0,     0,      9,   215,
     10,   215,     11,   215,     12,   215,     13,   215,     14,   215,
     15,   215,     16,   215,     17,   215,     18,   215,     19,   215,
     20,   215,     21,   215,     22,   215,     23,   215,     24,   215,

      0,     4,      0,   767,      0,     7,      0,   765,      0,     0,
      2,     0,      3,     0,      0,     0,      0,     0,      0,     0,
      9,   189,     10,   189,     11,   189,     12,   189,     13,   189,
     14,   215,     15,   189,     16,   189,     17,   189,     18,   189,
     19,   189,     20,   189,     21,   189,     22,   189,     23,   189,
     24,   189,      0,     4,      0,   741,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      9,   163,     10,   163,     11,   163,     12,   163,
     13,   163,     14,   163,     15,   163,     16,   163,     17,   163,
     18,   163,     19,   215,     20,   163,     21,   163,     22,   163,

     23,   163,     24,   163,      0,     4,      0,   715,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      9,   137,     10,   137,     11,   137,
     12,   137,     13,   137,     14,   137,     15,   137,     16,   137,
     17,   137,     18,   137,     19,   137,     20,   137,     21,   137,
     22,   137,     23,   137,     24,   215,      0,     4,      0,   689,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      9,   111,     10,   111,
     11,   111,     12,   111,     13,   111,     14,   111,     15,   215,
     16,   111,     17,   111,     18,   111,     19,   111,     20,   111,

     21,   111,     22,   111,     23,   111,     24,   111,      0,     4,
      0,   663,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      9,    85,
     10,    85,     11,    85,     12,    85,     13,    85,     14,    85,
     15,    85,     16,    85,     17,    85,     18,    85,     19,    85,
     20,    85,     21,    85,     22,   215,     23,    85,     24,    85,
      0,     4,      0,   637,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      9,    59,     10,    59,     11,    59,     12,    59,     13,    59,
     14,    59,     15,    59,     16,    59,     17,   215,     18,    59,

     19,    59,     20,    59,     21,    59,     22,    59,     23,    59,
     24,    59,      0,     8,      0,   611,      1,   215,      2,   215,
      0,     0,      4,   215,      5,   215,      6,   215,      7,   215,
      8,   215,      9,   215,     10,   215,     11,   215,     12,   215,
     13,   215,     14,   215,     15,   215,     16,   215,     17,   215,
     18,   215,     19,   215,     20,   215,     21,   215,     22,   215,
     23,   215,     24,   215,     25,   215,     26,    35,      0,     2,
      0,   583,      0,     0,      0,     1,      0,   580,      0,     4,
      0,   578,      0,     6,      0,   576,      0,     0,      9,   215,
      7,    -3,      0,     0,      9,     0,      0,     0,      9,     0,

     10,     0,     11,     0,     12,     0,     13,     0,     14,     0,
     15,     0,     16,     0,     17,     0,     18,     0,     19,     0,
     20,     0,     21,     0,     22,     0,     23,     0,     24,     0,
      0,     4,      0,   552,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      9,   -26,     10,   -26,     11,   -26,     12,   -26,     13,   -26,
     14,   -26,     15,   -26,     16,   186,     17,   -26,     18,   -26,
     19,   -26,     20,   -26,     21,   -26,     22,   -26,     23,   -26,
     24,   -26,      0,     4,      0,   526,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,

      0,     0,      9,   -52,     10,   -52,     11,   -52,     12,   -52,
     13,    52,     14,   -52,     15,   -52,     16,   -52,     17,   -52,
     18,   -52,     19,   -52,     20,   -52,     21,   -52,     22,   -52,
     23,   -52,     24,   -52,      0,     4,      0,   500,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      9,   -78,     10,   -78,     11,   -78,
     12,   -78,     13,   -78,     14,   -78,     15,   -78,     16,   -78,
     17,   -78,     18,   -78,     19,   160,     20,   -78,     21,   -78,
     22,   -78,     23,   -78,     24,   -78,      0,     3,      0,   474,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,

      0,     0,      0,     0,      0,     0,      9,  -104,     10,  -104,
     11,  -104,     12,  -104,     13,  -104,     14,  -104,     15,  -104,
     16,  -104,     17,  -104,     18,  -104,     19,  -104,     20,  -104,
     21,  -104,     22,  -104,     23,  -104,     24,  -104,      0,     4,
      0,   448,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      9,  -130,
     10,  -130,     11,  -130,     12,  -130,     13,  -130,     14,  -130,
     15,  -130,     16,  -130,     17,  -130,     18,  -130,     19,  -130,
     20,   134,     21,  -130,     22,  -130,     23,  -130,     24,  -130,
      0,     4,      0,   422,      0,     0,      0,     0,      0,     0,

      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      9,  -156,     10,  -156,     11,  -156,     12,  -156,     13,  -156,
     14,   134,     15,  -156,     16,  -156,     17,  -156,     18,  -156,
     19,  -156,     20,  -156,     21,  -156,     22,  -156,     23,  -156,
     24,  -156,      0,     0,      0,   396,      1,     0,      2,     0,
      0,     0,      4,     0,      5,     0,      6,     0,      7,     0,
      8,     0,      9,     0,     10,     0,     11,     0,     12,     0,
     13,     0,     14,     0,     15,     0,     16,     0,     17,     0,
     18,     0,     19,     0,     20,     0,     21,     0,     22,     0,
     23,     0,     24,     0,     25,     0,     26,  -180,      0,     2,

      0,   368,      0,     4,      0,   366,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      9,     0,
      0,     0,      9,  -212,     10,  -212,     11,  -212,     12,  -212,
     13,  -212,     14,  -212,     15,  -212,     16,  -212,     17,  -212,
     18,   104,     19,  -212,     20,  -212,     21,  -212,     22,  -212,
     23,  -212,     24,  -212,      0,     4,      0,   340,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      9,  -238,     10,  -238,     11,  -238,
     12,   104,     13,  -238,     14,  -238,     15,  -238,     16,  -238,
     17,  -238,     18,  -238,     19,  -238,     20,  -238,     21,  -238,

     22,  -238,     23,  -238,     24,  -238,      0,     4,      0,   314,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      9,  -264,     10,  -264,
     11,  -264,     12,   104,     13,  -264,     14,  -264,     15,  -264,
     16,  -264,     17,  -264,     18,  -264,     19,  -264,     20,  -264,
     21,  -264,     22,  -264,     23,  -264,     24,  -264,      0,     4,
      0,   288,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      9,  -290,
     10,  -290,     11,  -290,     12,  -290,     13,  -290,     14,  -290,
     15,  -290,     16,  -290,     17,  -290,     18,  -290,     19,  -186,

     20,  -290,     21,  -290,     22,  -290,     23,  -290,     24,  -290,
      0,     4,      0,   262,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      9,  -316,     10,  -316,     11,  -316,     12,  -316,     13,  -316,
     14,  -316,     15,  -316,     16,  -316,     17,  -316,     18,  -316,
     19,  -212,     20,  -316,     21,  -316,     22,  -316,     23,  -316,
     24,  -316,      0,     4,      0,   236,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      9,  -342,     10,  -342,     11,  -342,     12,  -342,
     13,  -342,     14,  -342,     15,  -342,     16,  -342,     17,  -342,

     18,  -342,     19,  -342,     20,  -342,     21,  -342,     22,  -342,
     23,    52,     24,  -342,      0,     4,      0,   210,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      9,  -368,     10,  -368,     11,  -368,
     12,  -368,     13,  -368,     14,    52,     15,  -368,     16,  -368,
     17,  -368,     18,  -368,     19,  -368,     20,  -368,     21,  -368,
     22,  -368,     23,  -368,     24,  -368,      0,     4,      0,   184,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      9,  -394,     10,  -394,
     11,  -394,     12,  -394,     13,  -394,     14,  -394,     15,  -394,

     16,  -394,     17,  -394,     18,    52,     19,  -394,     20,  -394,
     21,  -394,     22,  -394,     23,  -394,     24,  -394,      0,     4,
      0,   158,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      9,  -420,
     10,  -420,     11,  -420,     12,  -420,     13,    52,     14,  -420,
     15,  -420,     16,  -420,     17,  -420,     18,  -420,     19,  -420,
     20,  -420,     21,  -420,     22,  -420,     23,  -420,     24,  -420,
      0,     4,      0,   132,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      9,  -446,     10,  -446,     11,  -446,     12,  -446,     13,  -446,

     14,  -446,     15,  -446,     16,  -446,     17,  -446,     18,  -446,
     19,  -446,     20,    52,     21,  -446,     22,  -446,     23,  -446,
     24,  -446,      0,     4,      0,   106,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      9,  -472,     10,  -472,     11,  -472,     12,  -472,
     13,  -472,     14,  -472,     15,  -472,     16,  -472,     17,  -472,
     18,  -472,     19,  -472,     20,  -472,     21,  -472,     22,  -472,
     23,  -472,     24,    52,      0,     4,      0,    80,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      9,  -498,     10,  -498,     11,  -498,

     12,  -498,     13,  -498,     14,  -498,     15,  -498,     16,  -498,
     17,  -498,     18,  -498,     19,  -394,     20,  -498,     21,  -498,
     22,  -498,     23,  -498,     24,  -498,      0,     4,      0,    54,
      0,     0,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      9,  -524,     10,  -524,
     11,  -524,     12,  -524,     13,  -524,     14,  -524,     15,  -524,
     16,  -524,     17,  -524,     18,  -524,     19,  -524,     20,  -524,
     21,  -524,     22,    26,     23,  -524,     24,  -524,      0,     4,
      0,    28,      0,     0,      0,     0,      0,     0,      0,     0,
      0,     0,      0,     0,      0,     0,      0,     0,      9,  -550,

     10,  -550,     11,  -550,     12,  -550,     13,  -550,     14,  -446,
     15,  -550,     16,  -550,     17,  -550,     18,  -550,     19,  -550,
     20,  -550,     21,  -550,     22,  -550,     23,  -550,     24,  -550,
      0,     0,      0,     0,     27,    10,      1,     0,    };

static const struct yy_trans_info *yy_start_state_list[3] =
    {
    &yy_transition[1],
    &yy_transition[3],
    &yy_transition[31],


    } ;

static const YY_CHAR yy_ec[256] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    2,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    4,    5,    1,    6,    7,    8,    9,    9,    9,
        9,    9,    9,    9,    9,    9,    9,    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,    1,
        1,    1,    1,    1,    1,    1,   10,   11,   12,   13,

       14,   15,   16,   17,   18,   10,   10,   10,   10,   19,
       20,   21,   10,   22,   10,   23,   24,   10,   10,   10,
       10,   10,   25,    1,   26,    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,    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,    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,    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,    1,    1
    } ;

static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
char *yytext;
# line 1 "../inputs/in.0"
/* scanner for a toy Pascal-like language */
# line 4 "../inputs/in.0"
/* need this for the call to atof() below */
#include <math.h>

/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif

/* Copy whatever the last rule matched to the standard output. */

#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
		YY_FATAL_ERROR( "input in flex scanner failed" );
#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL int yylex YY_PROTO(( void ))
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif

YY_DECL
	{
	register yy_state_type yy_current_state;
	register char *yy_cp, *yy_bp;
	register int yy_act;

# line 11 "../inputs/in.0"



	if ( yy_init )
		{
#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

		if ( ! yy_start )
			yy_start = 1;	/* first start state */

		if ( ! yyin )
			yyin = stdin;

		if ( ! yyout )
			yyout = stdout;

		if ( yy_current_buffer )
			yy_init_buffer( yy_current_buffer, yyin );
		else
			yy_current_buffer =
				yy_create_buffer( yyin, YY_BUF_SIZE );

		yy_load_buffer_state();

		yy_init = 0;
		}

	while ( 1 )		/* loops until end-of-file is reached */
		{
		yy_cp = yy_c_buf_p;

		/* Support of yytext. */
		*yy_cp = yy_hold_char;

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = yy_start_state_list[yy_start];
yy_match:
		{
		register const struct yy_trans_info *yy_trans_info;

		register YY_CHAR yy_c;

		for ( yy_c = yy_ec[(unsigned int) *yy_cp];
		      (yy_trans_info = &yy_current_state[(unsigned int) yy_c])->
		yy_verify == yy_c;
		      yy_c = yy_ec[(unsigned int) *++yy_cp] )
			{
			yy_current_state += yy_trans_info->yy_nxt;

			if ( yy_current_state[-1].yy_nxt )
				{
				yy_last_accepting_state = yy_current_state;
				yy_last_accepting_cpos = yy_cp;
				}
			}
		}

yy_find_action:
		yy_act = yy_current_state[-1].yy_nxt;

		YY_DO_BEFORE_ACTION;

#ifdef YY_USER_ACTION
		if ( yy_act != YY_END_OF_BUFFER )
			{
			YY_USER_ACTION;
			}
#endif


do_action:	/* This label is used only to access EOF actions. */


		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = yy_hold_char;
			yy_cp = yy_last_accepting_cpos + 1;
			yy_current_state = yy_last_accepting_state;
			goto yy_find_action;

case 1:
# line 13 "../inputs/in.0"
{
		printf("An integer: %s (%d)\n", yytext, atoi(yytext));
		}
	YY_BREAK
case 2:
# line 17 "../inputs/in.0"
{
		printf("A float: %s (%g)\n", yytext, atof(yytext));
		}
	YY_BREAK
case 3:
# line 21 "../inputs/in.0"
{
		printf("A keyword: %s\n", yytext);
		}
	YY_BREAK
case 4:
# line 25 "../inputs/in.0"
printf("An identifier: %s\n", yytext);
	YY_BREAK
case 5:
# line 27 "../inputs/in.0"
printf("An operator: %s\n", yytext);
	YY_BREAK
case 6:
# line 29 "../inputs/in.0"
/* eat up one-line comments */
	YY_BREAK
case 7:
# line 31 "../inputs/in.0"
/* eat up whitespace */
	YY_BREAK
case 8:
# line 33 "../inputs/in.0"
printf("Unrecognized character: %s\n", yytext);
	YY_BREAK
case 9:
# line 35 "../inputs/in.0"
ECHO;
	YY_BREAK
case YY_STATE_EOF(INITIAL):
	yyterminate();

	case YY_END_OF_BUFFER:
		{
		/* Amount of text matched not including the EOB char. */
		int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;

		/* Undo the effects of YY_DO_BEFORE_ACTION. */
		*yy_cp = yy_hold_char;

		/* Note that here we test for yy_c_buf_p "<=" to the position
		 * of the first EOB in the buffer, since yy_c_buf_p will
		 * already have been incremented past the NUL character
		 * (since all states make transitions on EOB to the
		 * end-of-buffer state).  Contrast this with the test
		 * in input().
		 */
		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
			{ /* This was really a NUL. */
			yy_state_type yy_next_state;

			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;

			yy_current_state = yy_get_previous_state();

			/* Okay, we're now positioned to make the NUL
			 * transition.  We couldn't have
			 * yy_get_previous_state() go ahead and do it
			 * for us because it doesn't know how to deal
			 * with the possibility of jamming (and we don't
			 * want to build jamming into it because then it
			 * will run more slowly).
			 */

			yy_next_state = yy_try_NUL_trans( yy_current_state );

			yy_bp = yytext_ptr + YY_MORE_ADJ;

			if ( yy_next_state )
				{
				/* Consume the NUL. */
				yy_cp = ++yy_c_buf_p;
				yy_current_state = yy_next_state;
				goto yy_match;
				}

			else
				{
							yy_cp = yy_c_buf_p;
				goto yy_find_action;
				}
			}

		else switch ( yy_get_next_buffer() )
			{
			case EOB_ACT_END_OF_FILE:
				{
				yy_did_buffer_switch_on_eof = 0;

				if ( yywrap() )
					{
					/* Note: because we've taken care in
					 * yy_get_next_buffer() to have set up
					 * yytext, we can now set up
					 * yy_c_buf_p so that if some total
					 * hoser (like flex itself) wants to
					 * call the scanner after we return the
					 * YY_NULL, it'll still work - another
					 * YY_NULL will get returned.
					 */
					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;

					yy_act = YY_STATE_EOF(YY_START);
					goto do_action;
					}

				else
					{
					if ( ! yy_did_buffer_switch_on_eof )
						YY_NEW_FILE;
					}
				break;
				}

			case EOB_ACT_CONTINUE_SCAN:
				yy_c_buf_p =
					yytext_ptr + yy_amount_of_matched_text;

				yy_current_state = yy_get_previous_state();

				yy_cp = yy_c_buf_p;
				yy_bp = yytext_ptr + YY_MORE_ADJ;
				goto yy_match;

			case EOB_ACT_LAST_MATCH:
				yy_c_buf_p =
				&yy_current_buffer->yy_ch_buf[yy_n_chars];

				yy_current_state = yy_get_previous_state();

				yy_cp = yy_c_buf_p;
				yy_bp = yytext_ptr + YY_MORE_ADJ;
				goto yy_find_action;
			}
		break;
		}

	default:
#ifdef FLEX_DEBUG
		printf( "action # %d\n", yy_act );
#endif
		YY_FATAL_ERROR(
			"fatal flex scanner internal error--no action found" );
	} /* end of action switch */
		} /* end of scanning one token */
	} /* end of yylex */


/* yy_get_next_buffer - try to read in a new buffer
 *
 * Returns a code representing an action:
 *	EOB_ACT_LAST_MATCH -
 *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
 *	EOB_ACT_END_OF_FILE - end of file
 */

static int yy_get_next_buffer()
	{
	register char *dest = yy_current_buffer->yy_ch_buf;
	register char *source = yytext_ptr - 1; /* copy prev. char, too */
	register int number_to_move, i;
	int ret_val;

	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
		YY_FATAL_ERROR(
		"fatal flex scanner internal error--end of buffer missed" );

	/* Try to read more data. */

	/* First move last chars to start of buffer. */
	number_to_move = yy_c_buf_p - yytext_ptr;

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( yy_current_buffer->yy_eof_status != EOF_NOT_SEEN )
		/* don't do the read, it's not guaranteed to return an EOF,
		 * just force an EOF
		 */
		yy_n_chars = 0;

	else
		{
		int num_to_read =
			yy_current_buffer->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{ /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
			YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else

			/* just a shorter name for the current buffer */
			YY_BUFFER_STATE b = yy_current_buffer;

			int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;

			b->yy_buf_size *= 2;
			b->yy_ch_buf = (char *)
				yy_flex_realloc( (void *) b->yy_ch_buf,
						 b->yy_buf_size );

			if ( ! b->yy_ch_buf )
				YY_FATAL_ERROR(
				"fatal error - scanner input buffer overflow" );

			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = yy_current_buffer->yy_buf_size -
						number_to_move - 1;
#endif
			}

		if ( num_to_read > YY_READ_BUF_SIZE )
			num_to_read = YY_READ_BUF_SIZE;

		/* Read in more data. */
		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
			yy_n_chars, num_to_read );
		}

	if ( yy_n_chars == 0 )
		{
		if ( number_to_move - YY_MORE_ADJ == 1 )
			{
			ret_val = EOB_ACT_END_OF_FILE;
			yyrestart( yyin );
			}

		else
			{
			ret_val = EOB_ACT_LAST_MATCH;
			yy_current_buffer->yy_eof_status = EOF_PENDING;
			}
		}

	else
		ret_val = EOB_ACT_CONTINUE_SCAN;

	yy_n_chars += number_to_move;
	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

	/* yytext begins at the second character in yy_ch_buf; the first
	 * character is the one which preceded it before reading in the latest
	 * buffer; it needs to be kept around in case it's a newline, so
	 * yy_get_previous_state() will have with '^' rules active.
	 */

	yytext_ptr = &yy_current_buffer->yy_ch_buf[1];

	return ret_val;
	}


/* yy_get_previous_state - get the state just before the EOB char was reached */

static yy_state_type yy_get_previous_state()
	{
	register yy_state_type yy_current_state;
	register char *yy_cp;

	yy_current_state = yy_start_state_list[yy_start];

	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
		{
		yy_current_state += yy_current_state[(unsigned int) (*yy_cp ? yy_ec[(unsigned int) *yy_cp] : 1)].yy_nxt;
		if ( yy_current_state[-1].yy_nxt )
			{
			yy_last_accepting_state = yy_current_state;
			yy_last_accepting_cpos = yy_cp;
			}
		}

	return yy_current_state;
	}


/* yy_try_NUL_trans - try to make a transition on the NUL character
 *
 * synopsis
 *	next_state = yy_try_NUL_trans( current_state );
 */

#ifdef YY_USE_PROTOS
static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
#else
static yy_state_type yy_try_NUL_trans( yy_current_state )
yy_state_type yy_current_state;
#endif
	{
	register int yy_is_jam;
	register char *yy_cp = yy_c_buf_p;

	register int yy_c = 1;
	register const struct yy_trans_info *yy_trans_info;

	yy_trans_info = &yy_current_state[(unsigned int) yy_c];
	yy_current_state += yy_trans_info->yy_nxt;
	yy_is_jam = (yy_trans_info->yy_verify != yy_c);

	if ( ! yy_is_jam )
		{
		if ( yy_current_state[-1].yy_nxt )
			{
			yy_last_accepting_state = yy_current_state;
			yy_last_accepting_cpos = yy_cp;
			}
		}

	return yy_is_jam ? 0 : yy_current_state;
	}


#ifdef YY_USE_PROTOS
static void yyunput( int c, register char *yy_bp )
#else
static void yyunput( c, yy_bp )
int c;
register char *yy_bp;
#endif
	{
	register char *yy_cp = yy_c_buf_p;

	/* undo effects of setting up yytext */
	*yy_cp = yy_hold_char;

	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
		{ /* need to shift things up to make room */
		/* +2 for EOB chars. */
		register int number_to_move = yy_n_chars + 2;
		register char *dest = &yy_current_buffer->yy_ch_buf[
					yy_current_buffer->yy_buf_size + 2];
		register char *source =
				&yy_current_buffer->yy_ch_buf[number_to_move];

		while ( source > yy_current_buffer->yy_ch_buf )
			*--dest = *--source;

		yy_cp += dest - source;
		yy_bp += dest - source;
		yy_n_chars = yy_current_buffer->yy_buf_size;

		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
			YY_FATAL_ERROR( "flex scanner push-back overflow" );
		}

	if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
		yy_cp[-2] = '\n';

	*--yy_cp = (char) c;


	/* Note: the formal parameter *must* be called "yy_bp" for this
	 * macro to now work correctly.
	 */
	YY_DO_BEFORE_ACTION; /* set up yytext again */
	}


#ifdef __cplusplus
static int yyinput()
#else
static int input()
#endif
	{
	int c;

	*yy_c_buf_p = yy_hold_char;

	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
		{
		/* yy_c_buf_p now points to the character we want to return.
		 * If this occurs *before* the EOB characters, then it's a
		 * valid NUL; if not, then we've hit the end of the buffer.
		 */
		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
			/* This was really a NUL. */
			*yy_c_buf_p = '\0';

		else
			{ /* need more input */
			yytext_ptr = yy_c_buf_p;
			++yy_c_buf_p;

			switch ( yy_get_next_buffer() )
				{
				case EOB_ACT_END_OF_FILE:
					{
					if ( yywrap() )
						{
						yy_c_buf_p =
						yytext_ptr + YY_MORE_ADJ;
						return EOF;
						}

					YY_NEW_FILE;
#ifdef __cplusplus
					return yyinput();
#else
					return input();
#endif
					}

				case EOB_ACT_CONTINUE_SCAN:
					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
					break;

				case EOB_ACT_LAST_MATCH:
#ifdef __cplusplus
					YY_FATAL_ERROR(
					"unexpected last match in yyinput()" );
#else
					YY_FATAL_ERROR(
					"unexpected last match in input()" );
#endif
				}
			}
		}

	c = *yy_c_buf_p;
	*yy_c_buf_p = '\0';	/* preserve yytext */
	yy_hold_char = *++yy_c_buf_p;

	return c;
	}


#ifdef YY_USE_PROTOS
void yyrestart( FILE *input_file )
#else
void yyrestart( input_file )
FILE *input_file;
#endif
	{
	if ( ! yy_current_buffer )
		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

	yy_init_buffer( yy_current_buffer, input_file );
	yy_load_buffer_state();
	}


#ifdef YY_USE_PROTOS
void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
#else
void yy_switch_to_buffer( new_buffer )
YY_BUFFER_STATE new_buffer;
#endif
	{
	if ( yy_current_buffer == new_buffer )
		return;

	if ( yy_current_buffer )
		{
		/* Flush out information for old buffer. */
		*yy_c_buf_p = yy_hold_char;
		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
		yy_current_buffer->yy_n_chars = yy_n_chars;
		}

	yy_current_buffer = new_buffer;
	yy_load_buffer_state();

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	yy_did_buffer_switch_on_eof = 1;
	}


#ifdef YY_USE_PROTOS
void yy_load_buffer_state( void )
#else
void yy_load_buffer_state()
#endif
	{
	yy_n_chars = yy_current_buffer->yy_n_chars;
	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
	yyin = yy_current_buffer->yy_input_file;
	yy_hold_char = *yy_c_buf_p;
	}


#ifdef YY_USE_PROTOS
YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
#else
YY_BUFFER_STATE yy_create_buffer( file, size )
FILE *file;
int size;
#endif
	{
	YY_BUFFER_STATE b;

	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );

	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );

	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	yy_init_buffer( b, file );

	return b;
	}


#ifdef YY_USE_PROTOS
void yy_delete_buffer( YY_BUFFER_STATE b )
#else
void yy_delete_buffer( b )
YY_BUFFER_STATE b;
#endif
	{
	if ( b == yy_current_buffer )
		yy_current_buffer = (YY_BUFFER_STATE) 0;

	yy_flex_free( (void *) b->yy_ch_buf );
	yy_flex_free( (void *) b );
	}


#ifdef YY_USE_PROTOS
void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
#else
void yy_init_buffer( b, file )
YY_BUFFER_STATE b;
FILE *file;
#endif
	{
	b->yy_input_file = file;

	/* We put in the '\n' and start reading from [1] so that an
	 * initial match-at-newline will be true.
	 */

	b->yy_ch_buf[0] = '\n';
	b->yy_n_chars = 1;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[1];

	b->is_interactive = file ? isatty( fileno(file) ) : 0;

	b->yy_eof_status = EOF_NOT_SEEN;
	}


#ifdef YY_USE_PROTOS
static void yy_fatal_error( const char msg[] )
#else
static void yy_fatal_error( msg )
char msg[];
#endif
	{
FILE *err;
	(void) fprintf( err, "%s\n", msg );
	exit( 1 );
	}


/* Redefine yyless() so it works in section 3 code. */

#undef yyless
#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
		yytext[yyleng] = yy_hold_char; \
		yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
		yy_hold_char = *yy_c_buf_p; \
		*yy_c_buf_p = '\0'; \
		yyleng = n; \
		} \
	while ( 0 )
# line 35 "../inputs/in.0"


main(argc, argv)
int argc;
char **argv;
	{
	++argv, --argc;	/* skip over program name */
	if(argc > 0)
		yyin = fopen(argv[0], "r");
	else
		yyin = stdin;

	yylex();
	} 
