/********************************************************************
This file is part of the abs 0.907 distribution.  abs is a spreadsheet
with graphical user interface.

Copyright (C) 1998-2001  André Bertin (Andre.Bertin@ping.be) 

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version if in the same spirit as version 2.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Concact: abs@pi.be
         http://home.pi.be/bertin/abs.shtml

*********************************************************************/
































#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 5

#include <stdio.h>



#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif


#ifdef __cplusplus

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


#define YY_USE_PROTOS


#define YY_USE_CONST

#else 

#if __STDC__

#define YY_USE_PROTOS
#define YY_USE_CONST

#endif 
#endif 

#ifdef __TURBOC__
#pragma warn -rch
#pragma warn -use
#include <io.h>
#include <stdlib.h>
#define YY_USE_CONST
#define YY_USE_PROTOS
#endif

#ifdef YY_USE_CONST
#define yyconst const
#else
#define yyconst
#endif


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


#define YY_NULL 0






#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)





#define BEGIN yy_start = 1 + 2 *





#define YY_START ((yy_start - 1) / 2)
#define YYSTATE YY_START


#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)


#define YY_NEW_FILE yyrestart( yyin )

#define YY_END_OF_BUFFER_CHAR 0


#define YY_BUF_SIZE 16384

typedef struct yy_buffer_state *YY_BUFFER_STATE;

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

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

















#define yyless(n) \
	do \
		{ \
		/* Undo effects of setting up yytext. */ \
		*yy_cp = yy_hold_char; \
		YY_RESTORE_YY_MORE_OFFSET \
		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 )





typedef unsigned int yy_size_t;


struct yy_buffer_state
  {
    FILE *yy_input_file;

    char *yy_ch_buf;		
    char *yy_buf_pos;		

    
    
    
    yy_size_t yy_buf_size;

    
    
    
    int yy_n_chars;

    
    
    
    
    int yy_is_our_buffer;

    
    
    
    
    
    int yy_is_interactive;

    
    
    
    
    int yy_at_bol;

    
    
    
    int yy_fill_buffer;

    int yy_buffer_status;
#define YY_BUFFER_NEW 0
#define YY_BUFFER_NORMAL 1
    
    
    
    
    
    
    
    
    
    
#define YY_BUFFER_EOF_PENDING 2
  };

static YY_BUFFER_STATE yy_current_buffer = 0;





#define YY_CURRENT_BUFFER yy_current_buffer



static char yy_hold_char;

static int yy_n_chars;		


int yyleng;


static char *yy_c_buf_p = (char *) 0;
static int yy_init = 1;		
static int yy_start = 0;	




static int yy_did_buffer_switch_on_eof;

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));
void yy_flush_buffer YY_PROTO ((YY_BUFFER_STATE b));
#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )

YY_BUFFER_STATE yy_scan_buffer YY_PROTO ((char *base, yy_size_t size));
YY_BUFFER_STATE yy_scan_string YY_PROTO ((yyconst char *yy_str));
YY_BUFFER_STATE yy_scan_bytes YY_PROTO ((yyconst char *bytes, int len));

static void *yy_flex_alloc YY_PROTO ((yy_size_t));
static void *yy_flex_realloc YY_PROTO ((void *, yy_size_t));
static void yy_flex_free YY_PROTO ((void *));

#define yy_new_buffer yy_create_buffer

#define yy_set_interactive(is_interactive) \
	{ \
	if ( ! yy_current_buffer ) \
		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
	yy_current_buffer->yy_is_interactive = is_interactive; \
	}

#define yy_set_bol(at_bol) \
	{ \
	if ( ! yy_current_buffer ) \
		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
	yy_current_buffer->yy_at_bol = at_bol; \
	}

#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)

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

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 ((yyconst char msg[]));




#define YY_DO_BEFORE_ACTION \
	yytext_ptr = yy_bp; \
	yyleng = (int) (yy_cp - yy_bp); \
	yy_hold_char = *yy_cp; \
	*yy_cp = '\0'; \
	yy_c_buf_p = yy_cp;

#define YY_NUM_RULES 110
#define YY_END_OF_BUFFER 111
static yyconst short int yy_accept[338] =
{0,
 0, 0, 111, 107, 106, 104, 105, 88, 107, 62,
 96, 87, 107, 82, 83, 93, 92, 78, 91, 86,
 94, 68, 68, 79, 75, 97, 80, 99, 103, 84,
 95, 85, 101, 62, 62, 62, 62, 62, 62, 62,
 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
 62, 76, 102, 77, 90, 0, 74, 0, 62, 0,
 70, 0, 0, 63, 72, 73, 66, 0, 68, 68,
 0, 68, 98, 89, 81, 100, 62, 62, 3, 62,
 62, 62, 62, 62, 62, 62, 62, 62, 62, 17,
 62, 62, 62, 62, 62, 62, 62, 26, 27, 62,

 62, 62, 62, 62, 35, 62, 62, 62, 62, 62,
 62, 62, 62, 62, 62, 62, 44, 62, 62, 62,
 62, 62, 62, 0, 63, 0, 72, 72, 0, 73,
 66, 66, 0, 71, 68, 69, 64, 1, 62, 62,
 62, 62, 62, 62, 62, 62, 62, 62, 62, 62,
 62, 16, 62, 62, 62, 60, 62, 62, 24, 62,
 62, 62, 62, 62, 40, 62, 62, 62, 62, 62,
 62, 62, 62, 62, 47, 62, 59, 62, 62, 62,
 58, 42, 62, 62, 62, 62, 62, 62, 62, 108,
 0, 72, 0, 72, 0, 73, 66, 67, 71, 64,

 64, 62, 62, 62, 62, 62, 9, 62, 61, 11,
 62, 62, 62, 15, 62, 21, 22, 62, 23, 62,
 62, 62, 30, 31, 41, 62, 33, 62, 62, 62,
 62, 62, 62, 62, 62, 62, 50, 62, 43, 62,
 62, 54, 62, 55, 62, 0, 72, 64, 65, 62,
 62, 62, 62, 8, 10, 12, 13, 62, 62, 62,
 62, 28, 62, 62, 62, 62, 37, 62, 62, 62,
 62, 62, 62, 62, 52, 62, 56, 57, 2, 62,
 6, 62, 62, 18, 62, 62, 62, 32, 34, 36,
 62, 39, 45, 46, 48, 49, 51, 62, 62, 7,

 62, 62, 62, 29, 38, 53, 62, 14, 62, 62,
 25, 62, 62, 62, 62, 62, 62, 62, 62, 62,
 62, 62, 62, 62, 62, 62, 62, 62, 62, 19,
 62, 62, 20, 62, 4, 5, 0
};

static yyconst int yy_ec[256] =
{0,
 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1, 4, 5, 6, 1, 7, 8, 9, 10, 11,
 12, 13, 14, 15, 16, 17, 18, 19, 20, 20,
 20, 20, 20, 20, 20, 20, 20, 21, 22, 23,
 24, 25, 26, 1, 32, 33, 34, 35, 36, 37,
 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
 42, 48, 49, 50, 51, 52, 53, 54, 55, 42,
 27, 28, 29, 30, 31, 1, 32, 33, 34, 35,

 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
 46, 47, 42, 48, 49, 50, 51, 52, 53, 54,
 55, 42, 56, 57, 58, 59, 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 yyconst int yy_meta[60] =
{0,
 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,
 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 4, 3, 3, 3, 3, 3, 3, 2, 2, 2,
 2, 2, 3, 2, 2, 2, 2, 2, 2, 2,
 3, 2, 2, 2, 2, 1, 1, 1, 1
};

static yyconst short int yy_base[344] =
{0,
 0, 0, 420, 421, 421, 421, 421, 421, 54, 0,
 421, 421, 51, 421, 421, 421, 421, 421, 421, 43,
 421, 47, 52, 421, 421, 49, 395, 394, 421, 421,
 421, 421, 421, 31, 45, 43, 64, 70, 19, 47,
 371, 370, 379, 60, 58, 382, 78, 73, 368, 380,
 87, 421, 421, 421, 421, 71, 421, 408, 0, 110,
 421, 407, 111, 0, 111, 113, 117, 126, 358, 365,
 139, 144, 421, 421, 421, 421, 372, 359, 0, 367,
 359, 357, 100, 134, 356, 356, 352, 349, 354, 346,
 362, 346, 359, 356, 352, 343, 345, 0, 94, 120,

 354, 334, 346, 119, 0, 336, 345, 351, 338, 135,
 337, 347, 150, 347, 346, 342, 0, 327, 328, 330,
 334, 323, 332, 160, 0, 180, 421, 170, 188, 421,
 320, 327, 172, 190, 421, 421, 100, 0, 333, 328,
 335, 323, 329, 328, 331, 319, 325, 311, 310, 310,
 321, 0, 323, 316, 318, 322, 0, 302, 0, 317,
 299, 313, 310, 300, 0, 296, 309, 299, 303, 295,
 160, 298, 305, 303, 0, 300, 0, 287, 289, 295,
 0, 0, 289, 293, 292, 296, 287, 290, 278, 183,
 195, 197, 204, 421, 202, 206, 421, 421, 421, 276,

 283, 280, 279, 275, 286, 284, 0, 277, 0, 0,
 283, 268, 281, 0, 273, 0, 0, 269, 0, 264,
 263, 274, 0, 0, 0, 277, 0, 264, 258, 258,
 275, 266, 259, 270, 260, 262, 0, 256, 0, 257,
 267, 0, 262, 0, 261, 208, 210, 421, 421, 261,
 264, 239, 261, 0, 0, 0, 0, 247, 255, 253,
 249, 0, 252, 237, 241, 235, 0, 234, 249, 238,
 231, 244, 245, 240, 0, 232, 0, 0, 0, 230,
 0, 230, 240, 0, 242, 226, 223, 0, 0, 0,
 234, 0, 0, 0, 0, 0, 0, 219, 215, 0,

 196, 194, 205, 0, 0, 0, 217, 0, 201, 200,
 0, 195, 197, 209, 197, 196, 197, 186, 188, 200,
 183, 176, 159, 150, 141, 145, 128, 124, 130, 0,
 79, 81, 0, 65, 0, 0, 421, 253, 256, 260,
 263, 265, 65
};

static yyconst short int yy_def[344] =
{0,
 337, 1, 337, 337, 337, 337, 337, 337, 338, 339,
 337, 337, 340, 337, 337, 337, 337, 337, 337, 341,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 337, 337, 337, 337, 338, 337, 338, 339, 340,
 337, 340, 340, 342, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,

 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 340, 342, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 343, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 340,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,

 337, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 337, 337, 337, 337, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,

 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 339, 339, 339, 339,
 339, 339, 339, 339, 339, 339, 0, 337, 337, 337,
 337, 337, 337
};

static yyconst short int yy_nxt[481] =
{0,
 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
 10, 34, 35, 36, 37, 38, 39, 10, 10, 40,
 10, 10, 41, 42, 43, 44, 45, 46, 47, 48,
 49, 50, 51, 10, 10, 52, 53, 54, 55, 57,
 61, 65, 65, 66, 96, 67, 67, 137, 66, 97,
 72, 72, 73, 74, 84, 77, 57, 78, 62, 79,
 80, 58, 68, 98, 81, 85, 63, 68, 86, 69,
 82, 99, 103, 87, 69, 88, 336, 70, 58, 83,

 71, 91, 70, 89, 115, 107, 104, 105, 108, 90,
 106, 116, 92, 110, 93, 94, 335, 111, 117, 61,
 61, 334, 120, 95, 112, 121, 122, 113, 114, 65,
 65, 128, 128, 66, 123, 67, 67, 62, 62, 133,
 161, 133, 200, 162, 134, 134, 126, 143, 129, 144,
 201, 145, 68, 127, 168, 130, 124, 137, 137, 131,
 66, 333, 72, 72, 163, 164, 332, 132, 169, 61,
 137, 137, 137, 137, 137, 137, 146, 174, 331, 68,
 330, 178, 147, 329, 175, 179, 69, 62, 128, 128,
 134, 134, 61, 191, 70, 191, 190, 180, 192, 192,

 328, 195, 327, 195, 230, 193, 196, 196, 134, 134,
 62, 231, 194, 192, 192, 192, 192, 246, 326, 246,
 196, 196, 247, 247, 196, 196, 247, 247, 247, 247,
 309, 315, 199, 325, 324, 323, 322, 310, 316, 127,
 321, 320, 319, 318, 317, 314, 313, 312, 130, 311,
 308, 307, 194, 56, 56, 56, 56, 59, 59, 59,
 60, 60, 60, 60, 64, 64, 125, 125, 306, 305,
 304, 303, 302, 301, 300, 299, 298, 297, 296, 295,
 294, 293, 292, 291, 290, 289, 288, 287, 286, 285,
 284, 283, 282, 281, 280, 279, 278, 277, 276, 275,

 274, 273, 272, 271, 270, 269, 268, 267, 266, 265,
 264, 263, 262, 261, 260, 259, 258, 257, 256, 255,
 254, 253, 252, 251, 250, 249, 248, 245, 244, 243,
 242, 241, 240, 239, 238, 237, 236, 235, 234, 233,
 232, 229, 228, 227, 226, 225, 224, 223, 222, 221,
 220, 219, 218, 217, 216, 215, 214, 213, 212, 211,
 210, 209, 208, 207, 206, 205, 204, 203, 202, 198,
 197, 189, 188, 187, 186, 185, 184, 183, 182, 181,
 177, 176, 173, 172, 171, 170, 167, 166, 165, 160,
 159, 158, 157, 156, 155, 154, 153, 152, 151, 150,

 149, 148, 142, 141, 140, 139, 138, 136, 135, 337,
 337, 119, 118, 109, 102, 101, 100, 76, 75, 337,
 3, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337
};

static yyconst short int yy_chk[481] =
{0,
 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, 9,
 13, 20, 20, 22, 39, 22, 22, 343, 23, 39,
 23, 23, 26, 26, 36, 34, 56, 34, 13, 34,
 35, 9, 22, 40, 35, 36, 13, 23, 36, 22,
 35, 40, 44, 36, 23, 37, 334, 22, 56, 35,

 22, 38, 23, 37, 48, 45, 44, 44, 45, 37,
 44, 48, 38, 47, 38, 38, 332, 47, 48, 60,
 63, 331, 51, 38, 47, 51, 51, 47, 47, 65,
 65, 66, 66, 67, 51, 67, 67, 60, 63, 68,
 99, 68, 137, 99, 68, 68, 65, 83, 66, 83,
 137, 83, 67, 65, 104, 66, 63, 71, 71, 67,
 72, 329, 72, 72, 100, 100, 328, 67, 104, 124,
 71, 71, 71, 71, 71, 71, 84, 110, 327, 72,
 326, 113, 84, 325, 110, 113, 72, 124, 128, 128,
 133, 133, 190, 126, 72, 126, 124, 113, 126, 126,

 324, 129, 323, 129, 171, 128, 129, 129, 134, 134,
 190, 171, 128, 191, 191, 192, 192, 193, 322, 193,
 195, 195, 193, 193, 196, 196, 246, 246, 247, 247,
 302, 312, 134, 321, 320, 319, 318, 302, 312, 192,
 317, 316, 315, 314, 313, 310, 309, 307, 196, 303,
 301, 299, 247, 338, 338, 338, 338, 339, 339, 339,
 340, 340, 340, 340, 341, 341, 342, 342, 298, 291,
 287, 286, 285, 283, 282, 280, 276, 274, 273, 272,
 271, 270, 269, 268, 266, 265, 264, 263, 261, 260,
 259, 258, 253, 252, 251, 250, 245, 243, 241, 240,

 238, 236, 235, 234, 233, 232, 231, 230, 229, 228,
 226, 222, 221, 220, 218, 215, 213, 212, 211, 208,
 206, 205, 204, 203, 202, 201, 200, 189, 188, 187,
 186, 185, 184, 183, 180, 179, 178, 176, 174, 173,
 172, 170, 169, 168, 167, 166, 164, 163, 162, 161,
 160, 158, 156, 155, 154, 153, 151, 150, 149, 148,
 147, 146, 145, 144, 143, 142, 141, 140, 139, 132,
 131, 123, 122, 121, 120, 119, 118, 116, 115, 114,
 112, 111, 109, 108, 107, 106, 103, 102, 101, 97,
 96, 95, 94, 93, 92, 91, 90, 89, 88, 87,

 86, 85, 82, 81, 80, 78, 77, 70, 69, 62,
 58, 50, 49, 46, 43, 42, 41, 28, 27, 3,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337,
 337, 337, 337, 337, 337, 337, 337, 337, 337, 337
};

static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;




#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
char *yytext;
#line 1 "parser.l"
#define INITIAL 0
#line 12 "parser.l"
#include <stdio.h>
#include "y.tab.h"
#include "parser_ext.h"
#include "gram_ext.h"		


extern int yyerror (char *s);
extern int error (char *s);


#ifdef MYLEXDEBUG
#define LEXRETURN(x) printf("Lex: %d (%s)\n", (x), yytext); return (x)
#else
#define LEXRETURN(x) return(x)
#endif

static int eqisboolean = 0;
int 
seteqboolean ()
{
  eqisboolean = 1;
  return 0;
}
int 
unseteqboolean ()
{
  eqisboolean = 0;
  return 0;
}
extern int yylval;
#line 601 "lex.yy.c"





#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap YY_PROTO ((void));
#else
extern int yywrap YY_PROTO ((void));
#endif
#endif

#ifndef YY_NO_UNPUT
static void yyunput YY_PROTO ((int c, char *buf_ptr));
#endif

#ifndef yytext_ptr
static void yy_flex_strncpy YY_PROTO ((char *, yyconst char *, int));
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen YY_PROTO ((yyconst char *));
#endif

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

#if YY_STACK_USED
static int yy_start_stack_ptr = 0;
static int yy_start_stack_depth = 0;
static int *yy_start_stack = 0;
#ifndef YY_NO_PUSH_STATE
static void yy_push_state YY_PROTO ((int new_state));
#endif
#ifndef YY_NO_POP_STATE
static void yy_pop_state YY_PROTO ((void));
#endif
#ifndef YY_NO_TOP_STATE
static int yy_top_state YY_PROTO ((void));
#endif

#else
#define YY_NO_PUSH_STATE 1
#define YY_NO_POP_STATE 1
#define YY_NO_TOP_STATE 1
#endif

#ifdef YY_MALLOC_DECL
YY_MALLOC_DECL
#else
#if __STDC__
#ifndef __cplusplus
#include <stdlib.h>
#endif
#else




#endif
#endif


#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif



#ifndef ECHO



#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
#endif




#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( yy_current_buffer->yy_is_interactive ) \
		{ \
		int c = '*', n; \
		for ( n = 0; n < max_size && \
			     (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
		  && ferror( yyin ) ) \
		YY_FATAL_ERROR( "input in flex scanner failed" );
#endif





#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif


#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif


#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif




#ifndef YY_DECL
#define YY_DECL int yylex YY_PROTO(( void ))
#endif




#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif


#ifndef YY_BREAK
#define YY_BREAK break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

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

#line 33 "parser.l"

#line 754 "lex.yy.c"

  if (yy_init)
    {
      yy_init = 0;

#ifdef YY_USER_INIT
      YY_USER_INIT;
#endif

      if (!yy_start)
	yy_start = 1;		

      if (!yyin)
	yyin = stdin;

      if (!yyout)
	yyout = stdout;

      if (!yy_current_buffer)
	yy_current_buffer =
	  yy_create_buffer (yyin, YY_BUF_SIZE);

      yy_load_buffer_state ();
    }

  while (1)			
    {
      yy_cp = yy_c_buf_p;

      
      *yy_cp = yy_hold_char;

      
      
      
      yy_bp = yy_cp;

      yy_current_state = yy_start;
    yy_match:
      do
	{
	  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI (*yy_cp)];
	  if (yy_accept[yy_current_state])
	    {
	      yy_last_accepting_state = yy_current_state;
	      yy_last_accepting_cpos = yy_cp;
	    }
	  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
	    {
	      yy_current_state = (int) yy_def[yy_current_state];
	      if (yy_current_state >= 338)
		yy_c = yy_meta[(unsigned int) yy_c];
	    }
	  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
	  ++yy_cp;
	}
      while (yy_base[yy_current_state] != 421);

    yy_find_action:
      yy_act = yy_accept[yy_current_state];
      if (yy_act == 0)
	{			
	  yy_cp = yy_last_accepting_cpos;
	  yy_current_state = yy_last_accepting_state;
	  yy_act = yy_accept[yy_current_state];
	}

      YY_DO_BEFORE_ACTION;


    do_action:			


      switch (yy_act)
	{			
	case 0:		
	  
	  *yy_cp = yy_hold_char;
	  yy_cp = yy_last_accepting_cpos;
	  yy_current_state = yy_last_accepting_state;
	  goto yy_find_action;

	case 1:
	  YY_RULE_SETUP
#line 34 "parser.l"
	  {
	    LEXRETURN (AND);
	  }
	  YY_BREAK
	case 2:
	  YY_RULE_SETUP
#line 35 "parser.l"
	  {
	    LEXRETURN (APPEND);
	  }
	  YY_BREAK
	case 3:
	  YY_RULE_SETUP
#line 36 "parser.l"
	  {
	    LEXRETURN (AS);
	  }
	  YY_BREAK
	case 4:
	  YY_RULE_SETUP
#line 37 "parser.l"
	  {
	    LEXRETURN (BEGIN_OF_MODULE);
	  }
	  YY_BREAK
	case 5:
	  YY_RULE_SETUP
#line 38 "parser.l"
	  {
	    LEXRETURN (BEGIN_OF_FORMULA);
	  }
	  YY_BREAK
	case 6:
	  YY_RULE_SETUP
#line 39 "parser.l"
	  {
	    LEXRETURN (BINARY);
	  }
	  YY_BREAK
	case 7:
	  YY_RULE_SETUP
#line 40 "parser.l"
	  {
	    LEXRETURN (BOOLEAN);
	  }
	  YY_BREAK
	case 8:
	  YY_RULE_SETUP
#line 41 "parser.l"
	  {
	    LEXRETURN (BYREF);
	  }
	  YY_BREAK
	case 9:
	  YY_RULE_SETUP
#line 42 "parser.l"
	  {
	    LEXRETURN (BYTE);
	  }
	  YY_BREAK
	case 10:
	  YY_RULE_SETUP
#line 43 "parser.l"
	  {
	    LEXRETURN (BYVAL);
	  }
	  YY_BREAK
	case 11:
	  YY_RULE_SETUP
#line 44 "parser.l"
	  {
	    LEXRETURN (CASE);
	  }
	  YY_BREAK
	case 12:
	  YY_RULE_SETUP
#line 45 "parser.l"
	  {
	    LEXRETURN (CLOSE);
	  }
	  YY_BREAK
	case 13:
	  YY_RULE_SETUP
#line 46 "parser.l"
	  {
	    LEXRETURN (CONST);
	  }
	  YY_BREAK
	case 14:
	  YY_RULE_SETUP
#line 47 "parser.l"
	  {
	    LEXRETURN (CURRENCY);
	  }
	  YY_BREAK
	case 15:
	  YY_RULE_SETUP
#line 48 "parser.l"
	  {
	    LEXRETURN (DATE);
	  }
	  YY_BREAK
	case 16:
	  YY_RULE_SETUP
#line 49 "parser.l"
	  {
	    LEXRETURN (DIM);
	  }
	  YY_BREAK
	case 17:
	  YY_RULE_SETUP
#line 50 "parser.l"
	  {
	    LEXRETURN (DO);
	  }
	  YY_BREAK
	case 18:
	  YY_RULE_SETUP
#line 51 "parser.l"
	  {
	    LEXRETURN (DOUBLE);
	  }
	  YY_BREAK
	case 19:
	  YY_RULE_SETUP
#line 52 "parser.l"
	  {
	    LEXRETURN (END_OF_MODULE);
	  }
	  YY_BREAK
	case 20:
	  YY_RULE_SETUP
#line 53 "parser.l"
	  {
	    LEXRETURN (END_OF_FORMULA);
	  }
	  YY_BREAK
	case 21:
	  YY_RULE_SETUP
#line 54 "parser.l"
	  {
	    LEXRETURN (EACH);
	  }
	  YY_BREAK
	case 22:
	  YY_RULE_SETUP
#line 55 "parser.l"
	  {
	    LEXRETURN (ELSE);
	  }
	  YY_BREAK
	case 23:
	  YY_RULE_SETUP
#line 56 "parser.l"
	  {
	    LEXRETURN (EXIT);
	  }
	  YY_BREAK
	case 24:
	  YY_RULE_SETUP
#line 57 "parser.l"
	  {
	    LEXRETURN (FOR);
	  }
	  YY_BREAK
	case 25:
	  YY_RULE_SETUP
#line 58 "parser.l"
	  {
	    LEXRETURN (FUNCTION);
	  }
	  YY_BREAK
	case 26:
	  YY_RULE_SETUP
#line 59 "parser.l"
	  {
	    eqisboolean = 1;
	    LEXRETURN (IF);
	  }
	  YY_BREAK
	case 27:
	  YY_RULE_SETUP
#line 60 "parser.l"
	  {
	    LEXRETURN (IN);
	  }
	  YY_BREAK
	case 28:
	  YY_RULE_SETUP
#line 61 "parser.l"
	  {
	    LEXRETURN (INPUT);
	  }
	  YY_BREAK
	case 29:
	  YY_RULE_SETUP
#line 62 "parser.l"
	  {
	    LEXRETURN (INTEGER);
	  }
	  YY_BREAK
	case 30:
	  YY_RULE_SETUP
#line 63 "parser.l"
	  {
	    LEXRETURN (LONG);
	  }
	  YY_BREAK
	case 31:
	  YY_RULE_SETUP
#line 64 "parser.l"
	  {
	    LEXRETURN (LOOP);
	  }
	  YY_BREAK
	case 32:
	  YY_RULE_SETUP
#line 65 "parser.l"
	  {
	    LEXRETURN (OBJECT);
	  }
	  YY_BREAK
	case 33:
	  YY_RULE_SETUP
#line 66 "parser.l"
	  {
	    LEXRETURN (OPEN);
	  }
	  YY_BREAK
	case 34:
	  YY_RULE_SETUP
#line 67 "parser.l"
	  {
	    LEXRETURN (OPTION);
	  }
	  YY_BREAK
	case 35:
	  YY_RULE_SETUP
#line 68 "parser.l"
	  {
	    LEXRETURN (OR);
	  }
	  YY_BREAK
	case 36:
	  YY_RULE_SETUP
#line 69 "parser.l"
	  {
	    LEXRETURN (OUTPUT);
	  }
	  YY_BREAK
	case 37:
	  YY_RULE_SETUP
#line 70 "parser.l"
	  {
	    LEXRETURN (PRINT);
	  }
	  YY_BREAK
	case 38:
	  YY_RULE_SETUP
#line 71 "parser.l"
	  {
	    LEXRETURN (PRIVATE);
	  }
	  YY_BREAK
	case 39:
	  YY_RULE_SETUP
#line 72 "parser.l"
	  {
	    LEXRETURN (PUBLIC);
	  }
	  YY_BREAK
	case 40:
	  YY_RULE_SETUP
#line 73 "parser.l"
	  {
	    LEXRETURN (MOD);
	  }
	  YY_BREAK
	case 41:
	  YY_RULE_SETUP
#line 74 "parser.l"
	  {
	    LEXRETURN (NEXT);
	  }
	  YY_BREAK
	case 42:
	  YY_RULE_SETUP
#line 75 "parser.l"
	  {
	    LEXRETURN (TAB);
	  }
	  YY_BREAK
	case 43:
	  YY_RULE_SETUP
#line 76 "parser.l"
	  {
	    eqisboolean = 0;
	    LEXRETURN (THEN);
	  }
	  YY_BREAK
	case 44:
	  YY_RULE_SETUP
#line 77 "parser.l"
	  {
	    LEXRETURN (TO);
	  }
	  YY_BREAK
	case 45:
	  YY_RULE_SETUP
#line 78 "parser.l"
	  {
	    LEXRETURN (RANDOM);
	  }
	  YY_BREAK
	case 46:
	  YY_RULE_SETUP
#line 79 "parser.l"
	  {
	    LEXRETURN (SELECT);
	  }
	  YY_BREAK
	case 47:
	  YY_RULE_SETUP
#line 80 "parser.l"
	  {
	    LEXRETURN (SET);
	  }
	  YY_BREAK
	case 48:
	  YY_RULE_SETUP
#line 81 "parser.l"
	  {
	    LEXRETURN (SINGLE);
	  }
	  YY_BREAK
	case 49:
	  YY_RULE_SETUP
#line 82 "parser.l"
	  {
	    LEXRETURN (STATIC);
	  }
	  YY_BREAK
	case 50:
	  YY_RULE_SETUP
#line 83 "parser.l"
	  {
	    LEXRETURN (STEP);
	  }
	  YY_BREAK
	case 51:
	  YY_RULE_SETUP
#line 84 "parser.l"
	  {
	    LEXRETURN (STRING);
	  }
	  YY_BREAK
	case 52:
	  YY_RULE_SETUP
#line 85 "parser.l"
	  {
	    eqisboolean = 1;
	    LEXRETURN (UNTIL);
	  }
	  YY_BREAK
	case 53:
	  YY_RULE_SETUP
#line 86 "parser.l"
	  {
	    LEXRETURN (VARIANT);
	  }
	  YY_BREAK
	case 54:
	  YY_RULE_SETUP
#line 87 "parser.l"
	  {
	    LEXRETURN (WEND);
	  }
	  YY_BREAK
	case 55:
	  YY_RULE_SETUP
#line 88 "parser.l"
	  {
	    LEXRETURN (WITH);
	  }
	  YY_BREAK
	case 56:
	  YY_RULE_SETUP
#line 89 "parser.l"
	  {
	    eqisboolean = 1;
	    LEXRETURN (WHILE);
	  }
	  YY_BREAK
	case 57:
	  YY_RULE_SETUP
#line 90 "parser.l"
	  {
	    LEXRETURN (WRITE);
	  }
	  YY_BREAK
	case 58:
	  YY_RULE_SETUP
#line 91 "parser.l"
	  {
	    LEXRETURN (SUB);
	  }
	  YY_BREAK
	case 59:
	  YY_RULE_SETUP
#line 92 "parser.l"
	  {
	    LEXRETURN (SPC);
	  }
	  YY_BREAK
	case 60:
	  YY_RULE_SETUP
#line 93 "parser.l"
	  {
	    LEXRETURN (END);
	  }
	  YY_BREAK
	case 61:
	  YY_RULE_SETUP
#line 94 "parser.l"
	  {
	    LEXRETURN (CALL);
	  }
	  YY_BREAK
	case 62:
	  YY_RULE_SETUP
#line 96 "parser.l"
	  {
	    int t;
	    FillTokenBuf (yytext);
	    t = check_type ();
	    LEXRETURN (t);
	  }
	  YY_BREAK
	case 63:
	  YY_RULE_SETUP
#line 97 "parser.l"
	  {
	    int t;
	    FillTokenBuf (yytext);
	    t = check_member ();
	    LEXRETURN (t);
	  }
	  YY_BREAK
	case 64:
	  YY_RULE_SETUP
#line 99 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (INTEGER_CONSTANT);
	  }
	  YY_BREAK
	case 65:
	  YY_RULE_SETUP
#line 100 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (INTEGER_CONSTANT);
	  }
	  YY_BREAK
	case 66:
	  YY_RULE_SETUP
#line 101 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (INTEGER_CONSTANT);
	  }
	  YY_BREAK
	case 67:
	  YY_RULE_SETUP
#line 102 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (INTEGER_CONSTANT);
	  }
	  YY_BREAK
	case 68:
	  YY_RULE_SETUP
#line 103 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (INTEGER_CONSTANT);
	  }
	  YY_BREAK
	case 69:
	  YY_RULE_SETUP
#line 104 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (INTEGER_CONSTANT);
	  }
	  YY_BREAK
	case 70:
	  YY_RULE_SETUP
#line 106 "parser.l"
	  {
	    int t;
	    FillTokenBuf (yytext);
	    t = check_type ();
	    LEXRETURN (t);
	  }
	  YY_BREAK
	case 71:
	  YY_RULE_SETUP
#line 108 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (FLOATING_CONSTANT);
	  }
	  YY_BREAK
	case 72:
	  YY_RULE_SETUP
#line 109 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (FLOATING_CONSTANT);
	  }
	  YY_BREAK
	case 73:
	  YY_RULE_SETUP
#line 110 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (FLOATING_CONSTANT);
	  }
	  YY_BREAK
	case 74:
	  YY_RULE_SETUP
#line 112 "parser.l"
	  {
	    FillTokenBuf (yytext);
	    LEXRETURN (STRING_CONSTANT);
	  }
	  YY_BREAK
	case 75:
	  YY_RULE_SETUP
#line 115 "parser.l"
	  {
	    LEXRETURN (';');
	  }
	  YY_BREAK
	case 76:
	  YY_RULE_SETUP
#line 116 "parser.l"
	  {
	    LEXRETURN ('{');
	  }
	  YY_BREAK
	case 77:
	  YY_RULE_SETUP
#line 117 "parser.l"
	  {
	    LEXRETURN ('}');
	  }
	  YY_BREAK
	case 78:
	  YY_RULE_SETUP
#line 118 "parser.l"
	  {
	    LEXRETURN (',');
	  }
	  YY_BREAK
	case 79:
	  YY_RULE_SETUP
#line 119 "parser.l"
	  {
	    LEXRETURN (':');
	  }
	  YY_BREAK
	case 80:
	  YY_RULE_SETUP
#line 120 "parser.l"
	  {
	    if (eqisboolean)
	      LEXRETURN (EQ);
	    LEXRETURN ('=');
	  }
	  YY_BREAK
	case 81:
	  YY_RULE_SETUP
#line 122 "parser.l"
	  {
	    LEXRETURN (EQ);
	  }
	  YY_BREAK
	case 82:
	  YY_RULE_SETUP
#line 123 "parser.l"
	  {
	    LEXRETURN ('(');
	  }
	  YY_BREAK
	case 83:
	  YY_RULE_SETUP
#line 124 "parser.l"
	  {
	    LEXRETURN (')');
	  }
	  YY_BREAK
	case 84:
	  YY_RULE_SETUP
#line 125 "parser.l"
	  {
	    LEXRETURN ('[');
	  }
	  YY_BREAK
	case 85:
	  YY_RULE_SETUP
#line 126 "parser.l"
	  {
	    LEXRETURN (']');
	  }
	  YY_BREAK
	case 86:
	  YY_RULE_SETUP
#line 127 "parser.l"
	  {
	    LEXRETURN ('.');
	  }
	  YY_BREAK
	case 87:
	  YY_RULE_SETUP
#line 128 "parser.l"
	  {
	    LEXRETURN ('&');
	  }
	  YY_BREAK
	case 88:
	  YY_RULE_SETUP
#line 129 "parser.l"
	  {
	    LEXRETURN ('!');
	  }
	  YY_BREAK
	case 89:
	  YY_RULE_SETUP
#line 130 "parser.l"
	  {
	    LEXRETURN (NE);
	  }
	  YY_BREAK
	case 90:
	  YY_RULE_SETUP
#line 131 "parser.l"
	  {
	    LEXRETURN ('~');
	  }
	  YY_BREAK
	case 91:
	  YY_RULE_SETUP
#line 132 "parser.l"
	  {
	    LEXRETURN ('-');
	  }
	  YY_BREAK
	case 92:
	  YY_RULE_SETUP
#line 133 "parser.l"
	  {
	    LEXRETURN ('+');
	  }
	  YY_BREAK
	case 93:
	  YY_RULE_SETUP
#line 134 "parser.l"
	  {
	    LEXRETURN ('*');
	  }
	  YY_BREAK
	case 94:
	  YY_RULE_SETUP
#line 135 "parser.l"
	  {
	    LEXRETURN ('/');
	  }
	  YY_BREAK
	case 95:
	  YY_RULE_SETUP
#line 136 "parser.l"
	  {
	    LEXRETURN ('\\');
	  }
	  YY_BREAK
	case 96:
	  YY_RULE_SETUP
#line 137 "parser.l"
	  {
	    LEXRETURN ('%');
	  }
	  YY_BREAK
	case 97:
	  YY_RULE_SETUP
#line 138 "parser.l"
	  {
	    LEXRETURN (LT);
	  }
	  YY_BREAK
	case 98:
	  YY_RULE_SETUP
#line 139 "parser.l"
	  {
	    LEXRETURN (LE);
	  }
	  YY_BREAK
	case 99:
	  YY_RULE_SETUP
#line 140 "parser.l"
	  {
	    LEXRETURN (GT);
	  }
	  YY_BREAK
	case 100:
	  YY_RULE_SETUP
#line 141 "parser.l"
	  {
	    LEXRETURN (GE);
	  }
	  YY_BREAK
	case 101:
	  YY_RULE_SETUP
#line 142 "parser.l"
	  {
	    LEXRETURN ('^');
	  }
	  YY_BREAK
	case 102:
	  YY_RULE_SETUP
#line 143 "parser.l"
	  {
	    LEXRETURN ('|');
	  }
	  YY_BREAK
	case 103:
	  YY_RULE_SETUP
#line 144 "parser.l"
	  {
	    LEXRETURN ('?');
	  }
	  YY_BREAK
	case 104:
	  YY_RULE_SETUP
#line 146 "parser.l"
	  {
	    eqisboolean = 0;
	    LEXRETURN (NEWLINE);
	  }
	  YY_BREAK
	case 105:
	  YY_RULE_SETUP
#line 147 "parser.l"
	  {
	  }
	  YY_BREAK
	case 106:
	  YY_RULE_SETUP
#line 149 "parser.l"
	  {
	  }
	  YY_BREAK
	case 107:
	  YY_RULE_SETUP
#line 151 "parser.l"
	  {			
	  }
	  YY_BREAK
	case 108:
	  YY_RULE_SETUP
#line 153 "parser.l"
	  {
	    error ("unterminated quote");
	    yyerror ("unterminated quote");
	  }
	  YY_BREAK
	case 109:
	  YY_RULE_SETUP
#line 157 "parser.l"
	  {
	    yyerror ("end of file");
	  }
	  YY_BREAK
	case 110:
	  YY_RULE_SETUP
#line 161 "parser.l"
	    ECHO;
	  YY_BREAK
#line 1393 "lex.yy.c"
	case YY_STATE_EOF (INITIAL):
	  yyterminate ();

	case YY_END_OF_BUFFER:
	  {
	    
	    int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;

	    
	    *yy_cp = yy_hold_char;
	    YY_RESTORE_YY_MORE_OFFSET

	      if (yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW)
	      {
		
		
		
		
		
		
		
		
		
		yy_n_chars = yy_current_buffer->yy_n_chars;
		yy_current_buffer->yy_input_file = yyin;
		yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
	      }

	    
	    
	    
	    
	    
	    
	    
	    if (yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars])
	      {			
		yy_state_type yy_next_state;

		yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;

		yy_current_state = yy_get_previous_state ();

		
		
		
		
		
		
		
		

		yy_next_state = yy_try_NUL_trans (yy_current_state);

		yy_bp = yytext_ptr + YY_MORE_ADJ;

		if (yy_next_state)
		  {
		    
		    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 ())
		      {
			
			
			
			
			
			
			
			
			
			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:
	  YY_FATAL_ERROR (
		      "fatal flex scanner internal error--no action found");
	}			
    }				
}				










static int 
yy_get_next_buffer ()
{
  register char *dest = yy_current_buffer->yy_ch_buf;
  register char *source = yytext_ptr;
  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");

  if (yy_current_buffer->yy_fill_buffer == 0)
    {				
      if (yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1)
	{
	  
	  
	  
	  return EOB_ACT_END_OF_FILE;
	}

      else
	{
	  
	  
	  
	  return EOB_ACT_LAST_MATCH;
	}
    }

  

  
  number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;

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

  if (yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING)
    
    
    
    yy_current_buffer->yy_n_chars = yy_n_chars = 0;

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

      while (num_to_read <= 0)
	{			
#ifdef YY_USES_REJECT
	  YY_FATAL_ERROR (
			   "input buffer overflow, can't enlarge buffer because scanner uses REJECT");
#else

	  
	  YY_BUFFER_STATE b = yy_current_buffer;

	  int yy_c_buf_p_offset =
	  (int) (yy_c_buf_p - b->yy_ch_buf);

	  if (b->yy_is_our_buffer)
	    {
	      int new_size = b->yy_buf_size * 2;

	      if (new_size <= 0)
		b->yy_buf_size += b->yy_buf_size / 8;
	      else
		b->yy_buf_size *= 2;

	      b->yy_ch_buf = (char *)
	      
		yy_flex_realloc ((void *) b->yy_ch_buf,
				 b->yy_buf_size + 2);
	    }
	  else
	    
	    b->yy_ch_buf = 0;

	  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;

      
      YY_INPUT ((&yy_current_buffer->yy_ch_buf[number_to_move]),
		yy_n_chars, num_to_read);

      yy_current_buffer->yy_n_chars = yy_n_chars;
    }

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

      else
	{
	  ret_val = EOB_ACT_LAST_MATCH;
	  yy_current_buffer->yy_buffer_status =
	    YY_BUFFER_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_ptr = &yy_current_buffer->yy_ch_buf[0];

  return ret_val;
}




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

  yy_current_state = yy_start;

  for (yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp)
    {
      register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI (*yy_cp)] : 1);
      if (yy_accept[yy_current_state])
	{
	  yy_last_accepting_state = yy_current_state;
	  yy_last_accepting_cpos = yy_cp;
	}
      while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
	{
	  yy_current_state = (int) yy_def[yy_current_state];
	  if (yy_current_state >= 338)
	    yy_c = yy_meta[(unsigned int) yy_c];
	}
      yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    }

  return yy_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 YY_CHAR yy_c = 1;
  if (yy_accept[yy_current_state])
    {
      yy_last_accepting_state = yy_current_state;
      yy_last_accepting_cpos = yy_cp;
    }
  while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state)
    {
      yy_current_state = (int) yy_def[yy_current_state];
      if (yy_current_state >= 338)
	yy_c = yy_meta[(unsigned int) yy_c];
    }
  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
  yy_is_jam = (yy_current_state == 337);

  return yy_is_jam ? 0 : yy_current_state;
}


#ifndef YY_NO_UNPUT
#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;

  
  *yy_cp = yy_hold_char;

  if (yy_cp < yy_current_buffer->yy_ch_buf + 2)
    {				
      
      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 += (int) (dest - source);
      yy_bp += (int) (dest - source);
      yy_current_buffer->yy_n_chars =
	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");
    }

  *--yy_cp = (char) c;


  yytext_ptr = yy_bp;
  yy_hold_char = *yy_cp;
  yy_c_buf_p = yy_cp;
}
#endif 


#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)
    {
      
      
      
      
      if (yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars])
	
	*yy_c_buf_p = '\0';

      else
	{			
	  int offset = yy_c_buf_p - yytext_ptr;
	  ++yy_c_buf_p;

	  switch (yy_get_next_buffer ())
	    {
	    case EOB_ACT_LAST_MATCH:
	      
	      
	      
	      
	      
	      
	      
	      
	      

	      
	      yyrestart (yyin);

	      

	    case EOB_ACT_END_OF_FILE:
	      {
		if (yywrap ())
		  return EOF;

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

	    case EOB_ACT_CONTINUE_SCAN:
	      yy_c_buf_p = yytext_ptr + offset;
	      break;
	    }
	}
    }

  c = *(unsigned char *) yy_c_buf_p;	
  *yy_c_buf_p = '\0';		
  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)
    {
      
      *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 ();

  
  
  
  
  
  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;

  
  
  
  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()");

  b->yy_is_our_buffer = 1;

  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)
    return;

  if (b == yy_current_buffer)
    yy_current_buffer = (YY_BUFFER_STATE) 0;

  if (b->yy_is_our_buffer)
    yy_flex_free ((void *) b->yy_ch_buf);

  yy_flex_free ((void *) b);
}


#ifndef YY_ALWAYS_INTERACTIVE
#ifndef YY_NEVER_INTERACTIVE
extern int isatty YY_PROTO ((int));
#endif
#endif

#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


{
  yy_flush_buffer (b);

  b->yy_input_file = file;
  b->yy_fill_buffer = 1;

#if YY_ALWAYS_INTERACTIVE
  b->yy_is_interactive = 1;
#else
#if YY_NEVER_INTERACTIVE
  b->yy_is_interactive = 0;
#else
  b->yy_is_interactive = file ? (isatty (fileno (file)) > 0) : 0;
#endif
#endif
}


#ifdef YY_USE_PROTOS
void 
yy_flush_buffer (YY_BUFFER_STATE b)
#else
void 
yy_flush_buffer (b)
     YY_BUFFER_STATE b;
#endif

{
  if (!b)
    return;

  b->yy_n_chars = 0;

  
  
  
  
  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

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

  b->yy_at_bol = 1;
  b->yy_buffer_status = YY_BUFFER_NEW;

  if (b == yy_current_buffer)
    yy_load_buffer_state ();
}


#ifndef YY_NO_SCAN_BUFFER
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE 
yy_scan_buffer (char *base, yy_size_t size)
#else
YY_BUFFER_STATE 
yy_scan_buffer (base, size)
     char *base;
     yy_size_t size;
#endif
{
  YY_BUFFER_STATE b;

  if (size < 2 ||
      base[size - 2] != YY_END_OF_BUFFER_CHAR ||
      base[size - 1] != YY_END_OF_BUFFER_CHAR)
    
    return 0;

  b = (YY_BUFFER_STATE) yy_flex_alloc (sizeof (struct yy_buffer_state));
  if (!b)
    YY_FATAL_ERROR ("out of dynamic memory in yy_scan_buffer()");

  b->yy_buf_size = size - 2;	
  b->yy_buf_pos = b->yy_ch_buf = base;
  b->yy_is_our_buffer = 0;
  b->yy_input_file = 0;
  b->yy_n_chars = b->yy_buf_size;
  b->yy_is_interactive = 0;
  b->yy_at_bol = 1;
  b->yy_fill_buffer = 0;
  b->yy_buffer_status = YY_BUFFER_NEW;

  yy_switch_to_buffer (b);

  return b;
}
#endif


#ifndef YY_NO_SCAN_STRING
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE 
yy_scan_string (yyconst char *yy_str)
#else
YY_BUFFER_STATE 
yy_scan_string (yy_str)
     yyconst char *yy_str;
#endif
{
  int len;
  for (len = 0; yy_str[len]; ++len)
    ;

  return yy_scan_bytes (yy_str, len);
}
#endif


#ifndef YY_NO_SCAN_BYTES
#ifdef YY_USE_PROTOS
YY_BUFFER_STATE 
yy_scan_bytes (yyconst char *bytes, int len)
#else
YY_BUFFER_STATE 
yy_scan_bytes (bytes, len)
     yyconst char *bytes;
     int len;
#endif
{
  YY_BUFFER_STATE b;
  char *buf;
  yy_size_t n;
  int i;

  
  n = len + 2;
  buf = (char *) yy_flex_alloc (n);
  if (!buf)
    YY_FATAL_ERROR ("out of dynamic memory in yy_scan_bytes()");

  for (i = 0; i < len; ++i)
    buf[i] = bytes[i];

  buf[len] = buf[len + 1] = YY_END_OF_BUFFER_CHAR;

  b = yy_scan_buffer (buf, n);
  if (!b)
    YY_FATAL_ERROR ("bad buffer in yy_scan_bytes()");

  
  
  
  b->yy_is_our_buffer = 1;

  return b;
}
#endif


#ifndef YY_NO_PUSH_STATE
#ifdef YY_USE_PROTOS
static void 
yy_push_state (int new_state)
#else
static void 
yy_push_state (new_state)
     int new_state;
#endif
{
  if (yy_start_stack_ptr >= yy_start_stack_depth)
    {
      yy_size_t new_size;

      yy_start_stack_depth += YY_START_STACK_INCR;
      new_size = yy_start_stack_depth * sizeof (int);

      if (!yy_start_stack)
	yy_start_stack = (int *) yy_flex_alloc (new_size);

      else
	yy_start_stack = (int *) yy_flex_realloc (
					 (void *) yy_start_stack, new_size);

      if (!yy_start_stack)
	YY_FATAL_ERROR (
			 "out of memory expanding start-condition stack");
    }

  yy_start_stack[yy_start_stack_ptr++] = YY_START;

  BEGIN (new_state);
}
#endif


#ifndef YY_NO_POP_STATE
static void 
yy_pop_state ()
{
  if (--yy_start_stack_ptr < 0)
    YY_FATAL_ERROR ("start-condition stack underflow");

  BEGIN (yy_start_stack[yy_start_stack_ptr]);
}
#endif


#ifndef YY_NO_TOP_STATE
static int 
yy_top_state ()
{
  return yy_start_stack[yy_start_stack_ptr - 1];
}
#endif

#ifndef YY_EXIT_FAILURE
#define YY_EXIT_FAILURE 2
#endif

#ifdef YY_USE_PROTOS
static void 
yy_fatal_error (yyconst char msg[])
#else
static void 
yy_fatal_error (msg)
     char msg[];
#endif
{
  (void) fprintf (stderr, "%s\n", msg);
  exit (YY_EXIT_FAILURE);
}





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




#ifndef yytext_ptr
#ifdef YY_USE_PROTOS
static void 
yy_flex_strncpy (char *s1, yyconst char *s2, int n)
#else
static void 
yy_flex_strncpy (s1, s2, n)
     char *s1;
     yyconst char *s2;
     int n;
#endif
{
  register int i;
  for (i = 0; i < n; ++i)
    s1[i] = s2[i];
}
#endif

#ifdef YY_NEED_STRLEN
#ifdef YY_USE_PROTOS
static int 
yy_flex_strlen (yyconst char *s)
#else
static int 
yy_flex_strlen (s)
     yyconst char *s;
#endif
{
  register int n;
  for (n = 0; s[n]; ++n)
    ;

  return n;
}
#endif


#ifdef YY_USE_PROTOS
static void *
yy_flex_alloc (yy_size_t size)
#else
static void *
yy_flex_alloc (size)
     yy_size_t size;
#endif
{
  return (void *) malloc (size);
}

#ifdef YY_USE_PROTOS
static void *
yy_flex_realloc (void *ptr, yy_size_t size)
#else
static void *
yy_flex_realloc (ptr, size)
     void *ptr;
     yy_size_t size;
#endif
{
  
  
  
  
  
  
  
  return (void *) realloc ((char *) ptr, size);
}

#ifdef YY_USE_PROTOS
static void 
yy_flex_free (void *ptr)
#else
static void 
yy_flex_free (ptr)
     void *ptr;
#endif
{
  free (ptr);
}

#if YY_MAIN
int 
main ()
{
  yylex ();
  return 0;
}
#endif
#line 161 "parser.l"






