# include "stdio.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
# define YYLMAX 200
# define output(c) putc(c,yyout)
# define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
# define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
# define yymore() (yymorfg=1)
# define ECHO fprintf(yyout, "%s",yytext)
# define REJECT { nstr = yyreject(); goto yyfussy;}
int yyleng; extern char yytext[];
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 YYNEWLINE 10
yylex(){
int nstr; extern int yyprevious;
while((nstr = yylook()) >= 0)
yyfussy: switch(nstr){
case 0:
if(yywrap()) return(0); break;
case 1:
		printf(" mean");
break;
case 2:
		printf(" bitchin'est");
break;
case 3:
		printf(" bod");
break;
case 4:
		printf(" drag");
break;
case 5:
		printf(" rod ");
break;
case 6:
	printf(" grodie");
break;
case 7:
	printf(" grodie to thuh max");
break;
case 8:
		printf(" munchies");
break;
case 9:
		printf(" chick");
break;
case 10:
		printf(" bitchin'");
break;
case 11:
	printf(" awesum");
break;
case 12:
	printf(" grodie");
break;
case 13:
		printf(" dude");
break;
case 14:
		printf(" that chick ");
break;
case 15:
		printf(" that chick.");
break;
case 16:
		printf(" that dude ");
break;
case 17:
		printf(" that dude.");
break;
case 18:
	case 19:
	case 20:
case 21:
case 22:
	case 23:
case 24:
		case 25:
	case 26:
	case 27:
	case 28:
	{
			ECHO;
			switch(rand() % 6)
			{
			case 0:
				printf("like, ya know, "); break;
			case 1:
				printf(""); break;
			case 2:
				printf("like wow! "); break;
			case 3:
				printf("ya know, like, "); break;
			case 4:
				printf(""); break;
			case 5:
				printf(""); break;
			}
		}
break;
case 29:
	printf(" pad");
break;
case 30:
	printf(" cool");
break;
case 31:
	printf(" awesum");
break;
case 32:
	printf(" blow");
break;
case 33:
		printf(" nerd ");
break;
case 34:
{
			switch(rand() % 6)
			{
			case 0:
				printf(" if you're a Pisces "); break;
			case 1:
				printf(" if the moon is full "); break;
			case 2:
				printf(" if the vibes are right "); break;
			case 3:
				printf(" when you get the feeling "); break;
			case 4:
				printf(" maybe "); break;
			case 5:
				printf(" maybe "); break;
			}
		}
break;
case 35:
	printf(" party");
break;
case 36:
	printf(" flick");
break;
case 37:
	printf(" tunes ");
break;
case 38:
		printf(" keen");
break;
case 39:
		printf(" class");
break;
case 40:
	printf(" just no way");
break;
case 41:
	printf(" guys");
break;
case 42:
	printf(" totally");
break;
case 43:
	printf(" freaky");
break;
case 44:
		printf(" thuh ");
break;
case 45:
		printf(" super");
break;
case 46:
		printf(" want");
break;
case 47:
	printf(" far out");
break;
case 48:
		printf(" fer shure");
break;
case 49:
		printf("Man, ");
break;
case 50:
		printf("That dude ");
break;
case 51:
	printf("I can dig");
break;
case 52:
		printf("Like, no way,");
break;
case 53:
		printf("Man");
break;
case 54:
		printf("That fox ");
break;
case 55:
		printf("Like, ya know, this");
break;
case 56:
		printf("Like, there");
break;
case 57:
		printf("Us guys ");
break;
case 58:
		printf("Like,");
break;
case 59:
	{
			switch(rand() % 6)
			{
			case 0:
				printf(", like, "); break;
			case 1:
				printf(", fer shure, "); break;
			case 2:
				printf(", like, wow, "); break;
			case 3:
				printf(", oh, baby, "); break;
			case 4:
				printf(", man, "); break;
			case 5:
				printf(", mostly, "); break;
			}
		}
break;
case 60:
	{
			switch(rand() % 3)
			{
			case 0:
				printf("!  Gag me with a SPOOOOON!"); break;
			case 1:
				printf("!  Gag me with a pitchfork!"); break;
			case 2:
				printf("!  Oh, wow!");
			}
		}
break;
case 61:
		printf("in'");
break;
case 62:
		ECHO;
break;
case -1:
break;
default:
fprintf(yyout,"bad switch yylook %d",nstr);
} return(0); }
/* end of yylex */

main()
{
#ifdef AMIGA
	srand(12345);
#else
	srand(getpid());
#endif
	yylex();
}

#ifdef AMIGA
yywrap ()
{
	return (1);
}
#endif
int yyvstop[] = {
0,

62,
0,

62,
0,

60,
62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

62,
0,

59,
0,

50,
0,

52,
0,

53,
0,

57,
0,

61,
0,

1,
0,

2,
0,

13,
0,

28,
0,

48,
0,

49,
0,

54,
0,

55,
0,

58,
0,

3,
0,

4,
0,

5,
0,

8,
0,

9,
0,

10,
0,

14,
0,

15,
0,

16,
0,

17,
0,

33,
0,

38,
0,

39,
0,

44,
0,

45,
0,

46,
0,

24,
0,

56,
0,

6,
0,

11,
0,

12,
0,

29,
0,

31,
0,

32,
0,

36,
0,

47,
0,

51,
0,

7,
0,

34,
0,

37,
0,

40,
0,

41,
0,

42,
0,

18,
0,

35,
0,

43,
0,

25,
0,

26,
0,

19,
0,

27,
0,

22,
0,

30,
0,

23,
0,

20,
0,

21,
0,
0};
# define YYTYPE int
struct yywork { YYTYPE verify, advance; } yycrank[] = {
0,0,	0,0,	1,3,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	1,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	2,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,4,	1,5,	6,33,	
9,36,	0,0,	0,0,	0,0,	
0,0,	2,4,	2,5,	0,0,	
0,0,	1,6,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	2,6,	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,7,	
35,81,	0,0,	0,0,	0,0,	
0,0,	1,8,	1,9,	2,7,	
41,88,	0,0,	0,0,	1,10,	
0,0,	2,8,	2,9,	37,83,	
1,11,	1,12,	0,0,	2,10,	
1,13,	0,0,	1,14,	0,0,	
2,11,	2,12,	0,0,	0,0,	
2,13,	59,109,	2,14,	0,0,	
0,0,	0,0,	0,0,	17,47,	
8,35,	13,41,	1,15,	11,38,	
11,39,	12,40,	14,42,	4,16,	
4,17,	4,18,	2,15,	4,19,	
4,20,	4,21,	4,22,	10,37,	
7,34,	4,23,	4,24,	4,25,	
15,43,	4,26,	18,48,	4,27,	
4,28,	4,29,	16,44,	4,30,	
4,31,	19,49,	4,32,	22,58,	
20,51,	21,55,	16,45,	19,50,	
22,59,	21,56,	20,52,	26,69,	
16,46,	20,53,	23,60,	21,57,	
20,54,	24,62,	23,61,	25,66,	
27,70,	24,63,	28,71,	25,67,	
29,73,	30,74,	32,79,	34,80,	
31,75,	25,68,	36,82,	24,64,	
31,76,	38,84,	28,72,	39,85,	
31,77,	24,65,	42,89,	40,86,	
43,90,	44,91,	31,78,	40,87,	
45,92,	46,93,	47,95,	48,97,	
49,98,	50,99,	47,96,	51,100,	
52,101,	53,102,	54,104,	55,105,	
56,106,	57,107,	58,108,	46,94,	
60,110,	61,111,	62,112,	53,103,	
63,114,	64,115,	65,116,	66,117,	
67,118,	68,119,	69,120,	70,121,	
71,122,	62,113,	72,123,	73,124,	
74,125,	75,126,	76,128,	77,129,	
78,130,	79,131,	75,127,	80,132,	
82,133,	84,134,	86,135,	87,136,	
89,137,	93,138,	94,139,	95,140,	
96,142,	97,143,	98,144,	99,145,	
100,146,	101,147,	95,141,	102,148,	
103,149,	105,150,	106,152,	107,154,	
108,155,	110,156,	111,157,	112,158,	
113,159,	114,160,	115,161,	116,162,	
117,163,	118,164,	119,165,	105,151,	
106,153,	120,166,	121,167,	122,168,	
123,169,	124,170,	125,171,	126,172,	
127,173,	128,175,	129,176,	130,177,	
133,178,	135,179,	140,180,	141,181,	
143,182,	144,183,	148,184,	149,185,	
154,186,	155,187,	156,188,	157,189,	
159,190,	160,191,	161,192,	162,193,	
165,194,	166,195,	167,196,	168,197,	
169,198,	174,199,	175,200,	176,201,	
177,202,	178,203,	180,204,	181,205,	
183,206,	187,207,	190,208,	191,209,	
193,210,	194,211,	195,212,	196,213,	
197,214,	198,215,	199,216,	201,217,	
202,218,	204,219,	205,220,	207,221,	
209,222,	214,223,	215,225,	216,226,	
217,227,	218,228,	220,229,	221,230,	
223,231,	224,233,	227,234,	228,235,	
229,236,	230,237,	223,232,	231,238,	
232,239,	233,240,	235,241,	237,242,	
238,243,	239,244,	240,245,	242,246,	
244,247,	245,248,	247,250,	248,251,	
249,252,	250,253,	127,174,	245,249,	
251,254,	252,255,	253,256,	255,257,	
256,258,	257,259,	258,260,	259,261,	
260,262,	261,263,	263,264,	264,265,	
265,266,	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,	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,	214,224,	
0,0};
struct yysvf yysvec[] = {
0,	0,	0,
yycrank+-1,	0,		0,	
yycrank+-9,	yysvec+1,	0,	
yycrank+0,	0,		yyvstop+1,
yycrank+13,	0,		yyvstop+3,
yycrank+0,	0,		yyvstop+5,
yycrank+3,	0,		yyvstop+8,
yycrank+3,	0,		yyvstop+10,
yycrank+3,	0,		yyvstop+12,
yycrank+4,	0,		yyvstop+14,
yycrank+8,	0,		yyvstop+16,
yycrank+3,	0,		yyvstop+18,
yycrank+5,	0,		yyvstop+20,
yycrank+4,	0,		yyvstop+22,
yycrank+9,	0,		yyvstop+24,
yycrank+14,	0,		yyvstop+26,
yycrank+33,	0,		0,	
yycrank+6,	0,		0,	
yycrank+21,	0,		0,	
yycrank+28,	0,		0,	
yycrank+31,	0,		0,	
yycrank+36,	0,		0,	
yycrank+25,	0,		0,	
yycrank+49,	0,		0,	
yycrank+52,	0,		0,	
yycrank+50,	0,		0,	
yycrank+42,	0,		0,	
yycrank+51,	0,		0,	
yycrank+50,	0,		0,	
yycrank+52,	0,		0,	
yycrank+56,	0,		0,	
yycrank+63,	0,		0,	
yycrank+57,	0,		0,	
yycrank+0,	0,		yyvstop+28,
yycrank+43,	0,		0,	
yycrank+36,	0,		0,	
yycrank+54,	0,		0,	
yycrank+39,	0,		0,	
yycrank+64,	0,		0,	
yycrank+53,	0,		0,	
yycrank+70,	0,		0,	
yycrank+44,	0,		0,	
yycrank+55,	0,		0,	
yycrank+69,	0,		0,	
yycrank+73,	0,		0,	
yycrank+73,	0,		0,	
yycrank+77,	0,		0,	
yycrank+68,	0,		0,	
yycrank+65,	0,		0,	
yycrank+72,	0,		0,	
yycrank+70,	0,		0,	
yycrank+69,	0,		0,	
yycrank+73,	0,		0,	
yycrank+84,	0,		0,	
yycrank+65,	0,		0,	
yycrank+73,	0,		0,	
yycrank+79,	0,		0,	
yycrank+72,	0,		0,	
yycrank+74,	0,		0,	
yycrank+65,	0,		0,	
yycrank+78,	0,		0,	
yycrank+96,	0,		0,	
yycrank+84,	0,		0,	
yycrank+95,	0,		0,	
yycrank+79,	0,		0,	
yycrank+83,	0,		0,	
yycrank+102,	0,		0,	
yycrank+101,	0,		0,	
yycrank+169,	0,		0,	
yycrank+91,	0,		0,	
yycrank+106,	0,		0,	
yycrank+93,	0,		0,	
yycrank+92,	0,		0,	
yycrank+106,	0,		0,	
yycrank+94,	0,		0,	
yycrank+99,	0,		0,	
yycrank+105,	0,		0,	
yycrank+103,	0,		0,	
yycrank+102,	0,		0,	
yycrank+98,	0,		0,	
yycrank+183,	0,		0,	
yycrank+0,	0,		yyvstop+30,
yycrank+111,	0,		0,	
yycrank+0,	0,		yyvstop+32,
yycrank+185,	0,		0,	
yycrank+0,	0,		yyvstop+34,
yycrank+104,	0,		0,	
yycrank+104,	0,		0,	
yycrank+0,	0,		yyvstop+36,
yycrank+176,	0,		0,	
yycrank+0,	0,		yyvstop+38,
yycrank+0,	0,		yyvstop+40,
yycrank+0,	0,		yyvstop+42,
yycrank+100,	0,		0,	
yycrank+121,	0,		0,	
yycrank+191,	0,		0,	
yycrank+192,	0,		0,	
yycrank+109,	0,		0,	
yycrank+110,	0,		0,	
yycrank+127,	0,		0,	
yycrank+120,	0,		0,	
yycrank+129,	0,		0,	
yycrank+134,	0,		0,	
yycrank+117,	0,		0,	
yycrank+0,	0,		yyvstop+44,
yycrank+201,	0,		0,	
yycrank+202,	0,		0,	
yycrank+120,	0,		0,	
yycrank+135,	0,		0,	
yycrank+0,	0,		yyvstop+46,
yycrank+134,	0,		0,	
yycrank+120,	0,		0,	
yycrank+207,	0,		0,	
yycrank+142,	0,		0,	
yycrank+125,	0,		0,	
yycrank+137,	0,		0,	
yycrank+138,	0,		0,	
yycrank+128,	0,		0,	
yycrank+144,	0,		0,	
yycrank+127,	0,		0,	
yycrank+137,	0,		0,	
yycrank+142,	0,		0,	
yycrank+134,	0,		0,	
yycrank+155,	0,		0,	
yycrank+221,	0,		0,	
yycrank+133,	0,		0,	
yycrank+139,	0,		0,	
yycrank+224,	0,		0,	
yycrank+143,	0,		0,	
yycrank+150,	0,		0,	
yycrank+220,	0,		0,	
yycrank+0,	0,		yyvstop+48,
yycrank+0,	0,		yyvstop+50,
yycrank+153,	0,		0,	
yycrank+0,	0,		yyvstop+52,
yycrank+160,	0,		0,	
yycrank+0,	0,		yyvstop+54,
yycrank+0,	0,		yyvstop+56,
yycrank+0,	0,		yyvstop+58,
yycrank+0,	0,		yyvstop+60,
yycrank+164,	0,		0,	
yycrank+147,	0,		0,	
yycrank+0,	0,		yyvstop+62,
yycrank+143,	0,		0,	
yycrank+161,	0,		0,	
yycrank+0,	0,		yyvstop+64,
yycrank+0,	0,		yyvstop+66,
yycrank+0,	0,		yyvstop+68,
yycrank+150,	0,		0,	
yycrank+152,	0,		0,	
yycrank+0,	0,		yyvstop+70,
yycrank+0,	0,		yyvstop+72,
yycrank+0,	0,		yyvstop+74,
yycrank+0,	0,		yyvstop+76,
yycrank+167,	0,		0,	
yycrank+155,	0,		0,	
yycrank+169,	0,		0,	
yycrank+170,	0,		0,	
yycrank+0,	0,		yyvstop+78,
yycrank+171,	0,		0,	
yycrank+168,	0,		0,	
yycrank+173,	0,		0,	
yycrank+176,	0,		0,	
yycrank+0,	0,		yyvstop+80,
yycrank+0,	0,		yyvstop+82,
yycrank+179,	0,		0,	
yycrank+169,	0,		0,	
yycrank+170,	0,		0,	
yycrank+171,	0,		0,	
yycrank+170,	0,		0,	
yycrank+0,	0,		yyvstop+84,
yycrank+0,	0,		yyvstop+86,
yycrank+0,	0,		yyvstop+88,
yycrank+0,	0,		yyvstop+90,
yycrank+242,	0,		0,	
yycrank+182,	0,		0,	
yycrank+251,	0,		0,	
yycrank+168,	0,		0,	
yycrank+184,	0,		0,	
yycrank+0,	0,		yyvstop+92,
yycrank+185,	0,		0,	
yycrank+255,	0,		0,	
yycrank+0,	0,		yyvstop+94,
yycrank+167,	0,		0,	
yycrank+0,	0,		yyvstop+96,
yycrank+0,	0,		yyvstop+98,
yycrank+0,	0,		yyvstop+100,
yycrank+188,	0,		0,	
yycrank+0,	0,		yyvstop+102,
yycrank+0,	0,		yyvstop+104,
yycrank+258,	0,		0,	
yycrank+181,	0,		0,	
yycrank+0,	0,		yyvstop+106,
yycrank+260,	0,		0,	
yycrank+172,	0,		0,	
yycrank+193,	0,		0,	
yycrank+174,	0,		0,	
yycrank+196,	0,		0,	
yycrank+194,	0,		0,	
yycrank+182,	0,		0,	
yycrank+0,	0,		yyvstop+108,
yycrank+201,	0,		0,	
yycrank+268,	0,		0,	
yycrank+0,	0,		yyvstop+110,
yycrank+269,	0,		0,	
yycrank+204,	0,		0,	
yycrank+0,	0,		yyvstop+112,
yycrank+188,	0,		0,	
yycrank+0,	0,		yyvstop+114,
yycrank+201,	0,		0,	
yycrank+0,	0,		yyvstop+116,
yycrank+0,	0,		yyvstop+118,
yycrank+0,	0,		yyvstop+120,
yycrank+0,	0,		yyvstop+122,
yycrank+273,	0,		0,	
yycrank+205,	0,		0,	
yycrank+275,	0,		0,	
yycrank+207,	0,		0,	
yycrank+211,	0,		0,	
yycrank+0,	0,		yyvstop+124,
yycrank+209,	0,		0,	
yycrank+195,	0,		0,	
yycrank+0,	0,		yyvstop+126,
yycrank+214,	0,		0,	
yycrank+274,	0,		0,	
yycrank+0,	0,		yyvstop+128,
yycrank+0,	0,		yyvstop+130,
yycrank+282,	0,		0,	
yycrank+214,	0,		0,	
yycrank+284,	0,		0,	
yycrank+212,	0,		0,	
yycrank+218,	0,		0,	
yycrank+223,	0,		0,	
yycrank+205,	0,		0,	
yycrank+0,	0,		yyvstop+132,
yycrank+290,	0,		0,	
yycrank+0,	0,		yyvstop+134,
yycrank+213,	0,		0,	
yycrank+292,	0,		0,	
yycrank+207,	0,		0,	
yycrank+294,	0,		0,	
yycrank+0,	0,		yyvstop+136,
yycrank+224,	0,		0,	
yycrank+0,	0,		yyvstop+138,
yycrank+227,	0,		0,	
yycrank+231,	0,		0,	
yycrank+0,	0,		yyvstop+140,
yycrank+298,	0,		0,	
yycrank+230,	0,		0,	
yycrank+235,	0,		0,	
yycrank+235,	0,		0,	
yycrank+304,	0,		0,	
yycrank+219,	0,		0,	
yycrank+237,	0,		0,	
yycrank+0,	0,		yyvstop+142,
yycrank+238,	0,		0,	
yycrank+239,	0,		0,	
yycrank+309,	0,		0,	
yycrank+232,	0,		0,	
yycrank+245,	0,		0,	
yycrank+312,	0,		0,	
yycrank+244,	0,		0,	
yycrank+0,	0,		yyvstop+144,
yycrank+245,	0,		0,	
yycrank+237,	0,		0,	
yycrank+316,	0,		0,	
yycrank+0,	0,		yyvstop+146,
0,	0,	0};
struct yywork *yytop = yycrank+383;
struct yysvf *yybgin = yysvec+1;
char yymatch[] = {
00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,012 ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
0};
char yyextra[] = {
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,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};
/*	@(#)ncform	1.2	*/
int yylineno =1;
# define YYU(x) x
# define NLSTATE yyprevious=YYNEWLINE
char yytext[YYLMAX];
struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
char yysbuf[YYLMAX];
char *yysptr = yysbuf;
int *yyfnd;
extern struct yysvf *yyestate;
int yyprevious = YYNEWLINE;
yylook(){
	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;
				}
			*yylastch++ = yych = input();
			yyfirst=0;
		tryagain:
# ifdef LEXDEBUG
			if(debug){
				fprintf(yyout,"char ");
				allprint(yych);
				putchar('\n');
				}
# endif
			yyr = yyt;
			if ( (int)yyt > (int)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;
					goto contin;
					}
				}
# ifdef YYOPTIM
			else if((int)yyt < (int)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;
					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;
					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);
			}
		yyprevious = yytext[0] = input();
		if (yyprevious>0)
			output(yyprevious);
		yylastch=yytext;
# ifdef LEXDEBUG
		if(debug)putchar('\n');
# endif
		}
	}
yyback(p, m)
	int *p;
{
if (p==0) return(0);
while (*p)
	{
	if (*p++ == m)
		return(1);
	}
return(0);
}
	/* the following are only used in the lex library */
yyinput(){
	return(input());
	}
yyoutput(c)
  int c; {
	output(c);
	}
yyunput(c)
   int c; {
	unput(c);
	}