#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
# define U(x) x
# define NLSTATE yyprevious=YYNEWLINE
# define BEGIN yybgin = yysvec + 1 +
# define INITIAL 0
# define YYLERR yysvec
# define YYSTATE (yyestate-yysvec-1)
# define YYOPTIM 1
# ifndef YYLMAX 
# define YYLMAX BUFSIZ
# endif 
#ifndef __cplusplus
# define output(c) (void)putc(c,yyout)
#else
# define lex_output(c) (void)putc(c,yyout)
#endif

#if defined(__cplusplus) || defined(__STDC__)

#if defined(__cplusplus) && defined(__EXTERN_C__)
extern "C" {
#endif
	int yyback(int *, int);
	int yyinput(void);
	int yylook(void);
	void yyoutput(int);
	int yyracc(int);
	int yyreject(void);
	void yyunput(int);
	int yylex(void);
#ifdef YYLEX_E
	void yywoutput(wchar_t);
	wchar_t yywinput(void);
#endif
#ifndef yyless
	int yyless(int);
#endif
#ifndef yywrap
	int yywrap(void);
#endif
#ifdef LEXDEBUG
	void allprint(char);
	void sprint(char *);
#endif
#if defined(__cplusplus) && defined(__EXTERN_C__)
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
	void exit(int);
#ifdef __cplusplus
}
#endif

#endif
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
# define yymore() (yymorfg=1)
#ifndef __cplusplus
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
#else
# define lex_input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
#endif
#define ECHO fprintf(yyout, "%s",yytext)
# define REJECT { nstr = yyreject(); goto yyfussy;}
int yyleng;
#define YYISARRAY
char yytext[YYLMAX];
int yymorfg;
extern char *yysptr, yysbuf[];
int yytchar;
FILE *yyin = {stdin}, *yyout = {stdout};
extern int yylineno;
struct yysvf { 
	struct yywork *yystoff;
	struct yysvf *yyother;
	int *yystops;};
struct yysvf *yyestate;
extern struct yysvf yysvec[], *yybgin;
# define Comment 2
# define QuotedString 4


# line 6 "srdl.l"
/*
 * %a 21000
 * %n 1000
 * %o 42000
 * %p 3500
 *
 *   Mike Markowski (mm@arl.mil)
 *   March 16, 1998
 *
 *   Note: keyword() is stupid.  A better keyword search can
 *         be easily implemented, but wasn't for lack of time...
 *
 *   Another note: real numbers are not flexible enough.  Currently,
 *         at least one digit must follow a decimal point.  I.e.,
 *         1.0 is legal, but 1. is not.  However, both 0.5 and .5 are ok.
 */


# line 23 "srdl.l"
/*
 * Get rid of lex default macros input() and unput() since we want to
 * use trickier things.  Our versions are redefined in lexInput.c.
 * If you're not using AT&T lex, this will probably have to be changed.

*** #undef input
*** #undef unput
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "y.tab.h"

int	kw,		/* Keyword (string) token type (int). */
	lineno = 1;

void	yyerror();

# define YYNEWLINE 10
yylex(){
int nstr; extern int yyprevious;
#ifdef __cplusplus
/* to avoid CC and lint complaining yyfussy not being used ...*/
static int __lex_hack = 0;
if (__lex_hack) goto yyfussy;
#endif
while((nstr = yylook()) >= 0)
yyfussy: switch(nstr){
case 0:
if(yywrap()) return(0); break;
case 1:

# line 59 "srdl.l"
      	case 2:

# line 60 "srdl.l"
           	;
break;
case 3:

# line 62 "srdl.l"
           	{ lineno++; }
break;
case 4:

# line 64 "srdl.l"
		{ sscanf(yytext, "%lf", &(yylval.number));
			  return NUMBER; }
break;
case 5:

# line 67 "srdl.l"
		{ if (kw = keyword(yytext))
				return kw;
			  else {
				yylval.string = strdup(yytext);
				return STRING;
			  }; }
break;
case 6:

# line 74 "srdl.l"
		{ BEGIN QuotedString; }
break;
case 7:

# line 75 "srdl.l"
{ yymore(); }
break;
case 8:

# line 76 "srdl.l"
{ yymore(); yyleng--; }
break;
case 9:

# line 77 "srdl.l"
{ BEGIN INITIAL;
			  yytext[yyleng-1] = '\0';
			  yylval.string = strdup(yytext);
			  return STRING; }
break;
case 10:

# line 82 "srdl.l"
		{ BEGIN Comment; }
break;
case 11:

# line 83 "srdl.l"
	case 12:

# line 84 "srdl.l"
	/* Eat comment. */ ;
break;
case 13:

# line 85 "srdl.l"
	{ BEGIN INITIAL; }
break;
case 14:

# line 87 "srdl.l"
		case 15:

# line 88 "srdl.l"
		case 16:

# line 89 "srdl.l"
		case 17:

# line 90 "srdl.l"
		case 18:

# line 91 "srdl.l"
		case 19:

# line 92 "srdl.l"
		case 20:

# line 93 "srdl.l"
		case 21:

# line 94 "srdl.l"
		case 22:

# line 95 "srdl.l"
		case 23:

# line 96 "srdl.l"
		case 24:

# line 97 "srdl.l"
		case 25:

# line 98 "srdl.l"
		case 26:

# line 99 "srdl.l"
		{ return yytext[0]; }
break;
case 27:

# line 101 "srdl.l"
		{ yyerror(yytext); }
break;
case -1:
break;
default:
(void)fprintf(yyout,"bad switch yylook %d",nstr);
} return(0); }
/* end of yylex */

# line 104 "srdl.l"

struct keyword {
	char	*name;		/* String itself. */
	int	tokenType,	/* Its token type. */
		len;		/* Strlen(name). */
};

static struct keyword	keywords[] = {

	"anchor",	ANCHOR,		6,
	"at",		AT,		2,
	"attributes",	ATTRIBUTES,	10,
	"back",		BACK,		4,
	"bottom",	BOTTOM,		6,
	"center",	CENTER,		6,
	"circular",	CIRCULAR,	8,
	"cm",		CM,		2,
	"color",	COLOR,		5,
	"cursor",	CURSOR,		6,
	"e",		E,		1,
	"eng",		ENG,		3,
	"equation",	EQUATION,	8,
	"false",	FALSE,		5,
	"filename",	FILENAME,	8,
	"fold",		FOLD,		4,
	"font",		FONT,		4,
	"format",	FORMAT,		6,
	"fp",		FP,		2,
	"front",	FRONT,		5,
	"gap",		GAP,		3,
	"inch",		INCH,		4,
	"inches",	INCHES,		6,
	"label",	LABEL,		5,
	"left",		LEFT,		4,
	"length",	LENGTH,		6,
	"line",		LINE,		4,
	"material",	MATERIAL,	8,
	"min",		MIN,		3,
	"mm",		MM,		2,
	"more",		MORE,		4,
	"notation",	NOTATION,	8,
	"numberline",	NUMBERLINE,	10,
	"on",		ON,		2,
	"only",		ONLY,		4,
	"pi",		PI,		2,
	"position",	POSITION,	8,
	"range",	RANGE,		5,
	"reducer",	REDUCER,	7,
	"right",	RIGHT,		5,
	"scale",	SCALE,		5,
	"scientific",	SCIENTIFIC,	10,
	"segment",	SEGMENT,	7,
	"slide",	SLIDE,		5,
	"sliderule",	SLIDERULE,	9,
	"stator",	STATOR,		6,
	"step",		STEP,		4,
	"straight",	STRAIGHT,	8,
	"symbol",	SYMBOL,		6,
	"text",		TEXT,		4,
	"thickness",	THICKNESS,	9,
	"ticks",	TICKS,		5,
	"to",		TO,		2,
	"top",		TOP,		3,
	"true",		TRUE,		4,
	"width",	WIDTH,		5,
	"zoom",		ZOOM,		4,

	"sin",		FN,		3,
	"cos",		FN,		3,
	"tan",		FN,		3,
	"log",		FN,		3,
	"ln",		FN,		3,

	(char *) 0, 	0,		0
};

/*
 *	k e y w o r d ( )
 *
 *  See if string value matches a keyword.  First check lengths (quick,
 *  simple, possible match).  If same, only then do all out strcmp().
 *
 *  Note: This could be sped up if I took the time to write something
 *        better than a sequential search!
 */

int
keyword(char * s)
{
	struct keyword	*ptr = keywords;
	int	len;

	len = strlen(s);
	while (ptr->len != 0)
		if (len == ptr->len && !strcmp(ptr->name, s)) {
			if (ptr->tokenType == FN)
				yylval.string = strdup(yytext);
			return ptr->tokenType;	/* Keyword match. */
		} else
			ptr++;
	return 0;				/* No keyword match. */
}

/*
 *   y y e r r o r ( )
 */

void
yyerror(char * str)
{
	printf("line %d: %s (yytext='%s')\n", lineno, str, yytext);
}
int yyvstop[] = {
0,

27,
0, 

2,
27,
0, 

3,
0, 

6,
27,
0, 

24,
27,
0, 

17,
27,
0, 

18,
27,
0, 

20,
27,
0, 

21,
27,
0, 

19,
27,
0, 

22,
27,
0, 

27,
0, 

23,
27,
0, 

4,
27,
0, 

25,
27,
0, 

16,
27,
0, 

5,
27,
0, 

26,
27,
0, 

14,
27,
0, 

15,
27,
0, 

27,
-1,
0, 

11,
0, 

12,
0, 

11,
0, 

7,
0, 

9,
0, 

8,
0, 

2,
0, 

4,
0, 

10,
0, 

4,
0, 

5,
0, 

5,
0, 

-1,
0, 

1,
0, 

13,
0, 

4,
0, 
0};
# define YYTYPE unsigned char
struct yywork { YYTYPE verify, advance; } yycrank[] = {
0,0,	0,0,	1,7,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	1,8,	1,9,	
0,0,	8,34,	0,0,	0,0,	
8,34,	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,0,	0,0,	
0,0,	0,0,	0,0,	1,10,	
8,34,	0,0,	1,11,	0,0,	
0,0,	1,12,	1,13,	1,14,	
1,15,	1,16,	1,17,	1,18,	
1,19,	1,20,	4,30,	19,36,	
30,43,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	1,21,	
1,22,	0,0,	2,27,	0,0,	
2,11,	0,0,	1,23,	2,12,	
2,13,	2,14,	1,23,	2,16,	
2,17,	2,18,	2,19,	3,28,	
0,0,	35,44,	0,0,	0,0,	
0,0,	5,31,	0,0,	3,28,	
3,29,	2,21,	2,22,	0,0,	
0,0,	5,31,	5,31,	0,0,	
0,0,	1,7,	6,33,	1,24,	
18,35,	18,35,	18,35,	18,35,	
18,35,	18,35,	18,35,	18,35,	
18,35,	18,35,	0,0,	0,0,	
3,28,	35,44,	0,0,	0,0,	
0,0,	0,0,	5,32,	0,0,	
3,30,	3,28,	0,0,	2,7,	
0,0,	2,24,	3,28,	5,31,	
1,25,	0,0,	1,26,	20,37,	
5,31,	20,38,	20,38,	20,38,	
20,38,	20,38,	20,38,	20,38,	
20,38,	20,38,	20,38,	3,28,	
0,0,	0,0,	0,0,	3,28,	
0,0,	5,31,	0,0,	0,0,	
0,0,	5,31,	2,25,	0,0,	
2,26,	0,0,	0,0,	0,0,	
23,39,	23,39,	23,39,	23,39,	
23,39,	23,39,	23,39,	23,39,	
23,39,	23,39,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
5,33,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	0,0,	
0,0,	0,0,	0,0,	23,40,	
0,0,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	23,40,	
23,40,	23,40,	23,40,	27,41,	
0,0,	0,0,	0,0,	0,0,	
44,45,	0,0,	44,45,	27,41,	
27,42,	44,46,	44,46,	44,46,	
44,46,	44,46,	44,46,	44,46,	
44,46,	44,46,	44,46,	45,46,	
45,46,	45,46,	45,46,	45,46,	
45,46,	45,46,	45,46,	45,46,	
45,46,	0,0,	0,0,	0,0,	
27,41,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	27,41,	0,0,	0,0,	
0,0,	0,0,	27,41,	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,0,	0,0,	0,0,	27,41,	
0,0,	0,0,	0,0,	27,41,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	0,0,	0,0,	
0,0,	0,0,	39,39,	0,0,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	39,39,	39,39,	
39,39,	39,39,	0,0,	0,0,	
0,0};
struct yysvf yysvec[] = {
0,	0,	0,
yycrank+-1,	0,		0,	
yycrank+-27,	yysvec+1,	0,	
yycrank+-74,	0,		0,	
yycrank+-8,	yysvec+3,	0,	
yycrank+-80,	0,		0,	
yycrank+-2,	yysvec+5,	0,	
yycrank+0,	0,		yyvstop+1,
yycrank+4,	0,		yyvstop+3,
yycrank+0,	0,		yyvstop+6,
yycrank+0,	0,		yyvstop+8,
yycrank+0,	0,		yyvstop+11,
yycrank+0,	0,		yyvstop+14,
yycrank+0,	0,		yyvstop+17,
yycrank+0,	0,		yyvstop+20,
yycrank+0,	0,		yyvstop+23,
yycrank+0,	0,		yyvstop+26,
yycrank+0,	0,		yyvstop+29,
yycrank+48,	0,		yyvstop+32,
yycrank+9,	0,		yyvstop+34,
yycrank+81,	0,		yyvstop+37,
yycrank+0,	0,		yyvstop+40,
yycrank+0,	0,		yyvstop+43,
yycrank+108,	0,		yyvstop+46,
yycrank+0,	0,		yyvstop+49,
yycrank+0,	0,		yyvstop+52,
yycrank+0,	0,		yyvstop+55,
yycrank+-230,	0,		yyvstop+58,
yycrank+0,	0,		yyvstop+61,
yycrank+0,	0,		yyvstop+63,
yycrank+5,	0,		yyvstop+65,
yycrank+0,	0,		yyvstop+67,
yycrank+0,	0,		yyvstop+69,
yycrank+0,	0,		yyvstop+71,
yycrank+0,	yysvec+8,	yyvstop+73,
yycrank+8,	yysvec+18,	yyvstop+75,
yycrank+0,	0,		yyvstop+77,
yycrank+0,	yysvec+18,	0,	
yycrank+0,	yysvec+20,	yyvstop+79,
yycrank+235,	yysvec+23,	yyvstop+81,
yycrank+0,	yysvec+23,	yyvstop+83,
yycrank+0,	yysvec+27,	yyvstop+85,
yycrank+0,	0,		yyvstop+87,
yycrank+0,	0,		yyvstop+89,
yycrank+193,	0,		0,	
yycrank+203,	0,		0,	
yycrank+0,	yysvec+45,	yyvstop+91,
0,	0,	0};
struct yywork *yytop = yycrank+357;
struct yysvf *yybgin = yysvec+1;
char yymatch[] = {
  0,   1,   1,   1,   1,   1,   1,   1, 
  1,   9,  10,   1,   9,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  9,   1,  34,   1,   1,   1,   1,   1, 
  1,   1,   1,  43,   1,  43,   1,   1, 
 48,  48,  48,  48,  48,  48,  48,  48, 
 48,  48,   1,   1,   1,   1,   1,   1, 
  1,  65,  65,  65,  65,  69,  65,  65, 
 65,  65,  65,  65,  65,  65,  65,  65, 
 65,  65,  65,  65,  65,  65,  65,  65, 
 65,  65,  65,   1,  34,   1,   1,  65, 
  1,  65,  65,  65,  65,  69,  65,  65, 
 65,  65,  65,  65,  65,  65,  65,  65, 
 65,  65,  65,  65,  65,  65,  65,  65, 
 65,  65,  65,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
0};
char yyextra[] = {
0,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,0,0,0,
0};
/*	Copyright (c) 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T	*/
/*	The copyright notice above does not evidence any   	*/
/*	actual or intended publication of such source code.	*/

#pragma ident	"@(#)ncform	6.12	97/12/08 SMI"

int yylineno =1;
# define YYU(x) x
# define NLSTATE yyprevious=YYNEWLINE
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
char yysbuf[YYLMAX];
char *yysptr = yysbuf;
int *yyfnd;
extern struct yysvf *yyestate;
int yyprevious = YYNEWLINE;
#if defined(__cplusplus) || defined(__STDC__)
int yylook(void)
#else
yylook()
#endif
{
	register struct yysvf *yystate, **lsp;
	register struct yywork *yyt;
	struct yysvf *yyz;
	int yych, yyfirst;
	struct yywork *yyr;
# ifdef LEXDEBUG
	int debug;
# endif
	char *yylastch;
	/* start off machines */
# ifdef LEXDEBUG
	debug = 0;
# endif
	yyfirst=1;
	if (!yymorfg)
		yylastch = yytext;
	else {
		yymorfg=0;
		yylastch = yytext+yyleng;
		}
	for(;;){
		lsp = yylstate;
		yyestate = yystate = yybgin;
		if (yyprevious==YYNEWLINE) yystate++;
		for (;;){
# ifdef LEXDEBUG
			if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
# endif
			yyt = yystate->yystoff;
			if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
				yyz = yystate->yyother;
				if(yyz == 0)break;
				if(yyz->yystoff == yycrank)break;
				}
#ifndef __cplusplus
			*yylastch++ = yych = input();
#else
			*yylastch++ = yych = lex_input();
#endif
#ifdef YYISARRAY
			if(yylastch > &yytext[YYLMAX]) {
				fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
				exit(1);
			}
#else
			if (yylastch >= &yytext[ yytextsz ]) {
				int	x = yylastch - yytext;

				yytextsz += YYTEXTSZINC;
				if (yytext == yy_tbuf) {
				    yytext = (char *) malloc(yytextsz);
				    memcpy(yytext, yy_tbuf, sizeof (yy_tbuf));
				}
				else
				    yytext = (char *) realloc(yytext, yytextsz);
				if (!yytext) {
				    fprintf(yyout,
					"Cannot realloc yytext\n");
				    exit(1);
				}
				yylastch = yytext + x;
			}
#endif
			yyfirst=0;
		tryagain:
# ifdef LEXDEBUG
			if(debug){
				fprintf(yyout,"char ");
				allprint(yych);
				putchar('\n');
				}
# endif
			yyr = yyt;
			if ( (uintptr_t)yyt > (uintptr_t)yycrank){
				yyt = yyr + yych;
				if (yyt <= yytop && yyt->verify+yysvec == yystate){
					if(yyt->advance+yysvec == YYLERR)	/* error transitions */
						{unput(*--yylastch);break;}
					*lsp++ = yystate = yyt->advance+yysvec;
					if(lsp > &yylstate[YYLMAX]) {
						fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
						exit(1);
					}
					goto contin;
					}
				}
# ifdef YYOPTIM
			else if((uintptr_t)yyt < (uintptr_t)yycrank) {	/* r < yycrank */
				yyt = yyr = yycrank+(yycrank-yyt);
# ifdef LEXDEBUG
				if(debug)fprintf(yyout,"compressed state\n");
# endif
				yyt = yyt + yych;
				if(yyt <= yytop && yyt->verify+yysvec == yystate){
					if(yyt->advance+yysvec == YYLERR)	/* error transitions */
						{unput(*--yylastch);break;}
					*lsp++ = yystate = yyt->advance+yysvec;
					if(lsp > &yylstate[YYLMAX]) {
						fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
						exit(1);
					}
					goto contin;
					}
				yyt = yyr + YYU(yymatch[yych]);
# ifdef LEXDEBUG
				if(debug){
					fprintf(yyout,"try fall back character ");
					allprint(YYU(yymatch[yych]));
					putchar('\n');
					}
# endif
				if(yyt <= yytop && yyt->verify+yysvec == yystate){
					if(yyt->advance+yysvec == YYLERR)	/* error transition */
						{unput(*--yylastch);break;}
					*lsp++ = yystate = yyt->advance+yysvec;
					if(lsp > &yylstate[YYLMAX]) {
						fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
						exit(1);
					}
					goto contin;
					}
				}
			if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
# ifdef LEXDEBUG
				if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
# endif
				goto tryagain;
				}
# endif
			else
				{unput(*--yylastch);break;}
		contin:
# ifdef LEXDEBUG
			if(debug){
				fprintf(yyout,"state %d char ",yystate-yysvec-1);
				allprint(yych);
				putchar('\n');
				}
# endif
			;
			}
# ifdef LEXDEBUG
		if(debug){
			fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
			allprint(yych);
			putchar('\n');
			}
# endif
		while (lsp-- > yylstate){
			*yylastch-- = 0;
			if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
				yyolsp = lsp;
				if(yyextra[*yyfnd]){		/* must backup */
					while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
						lsp--;
						unput(*yylastch--);
						}
					}
				yyprevious = YYU(*yylastch);
				yylsp = lsp;
				yyleng = yylastch-yytext+1;
				yytext[yyleng] = 0;
# ifdef LEXDEBUG
				if(debug){
					fprintf(yyout,"\nmatch ");
					sprint(yytext);
					fprintf(yyout," action %d\n",*yyfnd);
					}
# endif
				return(*yyfnd++);
				}
			unput(*yylastch);
			}
		if (yytext[0] == 0  /* && feof(yyin) */)
			{
			yysptr=yysbuf;
			return(0);
			}
#ifndef __cplusplus
		yyprevious = yytext[0] = input();
		if (yyprevious>0)
			output(yyprevious);
#else
		yyprevious = yytext[0] = lex_input();
		if (yyprevious>0)
			lex_output(yyprevious);
#endif
		yylastch=yytext;
# ifdef LEXDEBUG
		if(debug)putchar('\n');
# endif
		}
	}
#if defined(__cplusplus) || defined(__STDC__)
int yyback(int *p, int m)
#else
yyback(p, m)
	int *p;
#endif
{
	if (p==0) return(0);
	while (*p) {
		if (*p++ == m)
			return(1);
	}
	return(0);
}
	/* the following are only used in the lex library */
#if defined(__cplusplus) || defined(__STDC__)
int yyinput(void)
#else
yyinput()
#endif
{
#ifndef __cplusplus
	return(input());
#else
	return(lex_input());
#endif
	}
#if defined(__cplusplus) || defined(__STDC__)
void yyoutput(int c)
#else
yyoutput(c)
  int c; 
#endif
{
#ifndef __cplusplus
	output(c);
#else
	lex_output(c);
#endif
	}
#if defined(__cplusplus) || defined(__STDC__)
void yyunput(int c)
#else
yyunput(c)
   int c; 
#endif
{
	unput(c);
	}