#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
# define U(x) x
# define NLSTATE dgoprevious=YYNEWLINE
# define BEGIN dgobgin = dgosvec + 1 +
# define INITIAL 0
# define YYLERR dgosvec
# define YYSTATE (dgoestate-dgosvec-1)
# define YYOPTIM 1
# ifndef YYLMAX 
# define YYLMAX BUFSIZ
# endif 
#ifndef __cplusplus
# define output(c) (void)putc(c,dgoout)
#else
# define lex_output(c) (void)putc(c,dgoout)
#endif

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

#if defined(__cplusplus) && defined(__EXTERN_C__)
extern "C" {
#endif
	int dgoback(int *, int);
	int dgoinput(void);
	int dgolook(void);
	void dgooutput(int);
	int dgoracc(int);
	int dgoreject(void);
	void dgounput(int);
	int dgolex(void);
#ifdef YYLEX_E
	void dgowoutput(wchar_t);
	wchar_t dgowinput(void);
#endif
#ifndef dgoless
	int dgoless(int);
#endif
#ifndef dgowrap
	int dgowrap(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) {dgotchar= (c);if(dgotchar=='\n')dgolineno--;*dgosptr++=dgotchar;}
# define dgomore() (dgomorfg=1)
#ifndef __cplusplus
# define input() (((dgotchar=dgosptr>dgosbuf?U(*--dgosptr):getc(dgoin))==10?(dgolineno++,dgotchar):dgotchar)==EOF?0:dgotchar)
#else
# define lex_input() (((dgotchar=dgosptr>dgosbuf?U(*--dgosptr):getc(dgoin))==10?(dgolineno++,dgotchar):dgotchar)==EOF?0:dgotchar)
#endif
#define ECHO fprintf(dgoout, "%s",dgotext)
# define REJECT { nstr = dgoreject(); goto dgofussy;}
int dgoleng;
#define YYISARRAY
char dgotext[YYLMAX];
int dgomorfg;
extern char *dgosptr, dgosbuf[];
int dgotchar;
FILE *dgoin = {stdin}, *dgoout = {nabout};
extern int dgolineno;
struct dgosvf { 
	struct dgowork *dgostoff;
	struct dgosvf *dgoother;
	int *dgostops;};
struct dgosvf *dgoestate;
extern struct dgosvf dgosvec[], *dgobgin;

#ifdef flex

#undef YY_INPUT
#define YY_INPUT(b, r, ms) (r = dgo_dgoinput(b, ms))

#else

#undef input
#undef unput
#define input() (*gopts++)
#define unput(c) (*--gopts = c)

#endif

#undef ECHO
#define ECHO fprintf(dgoout, "\tdg_options:  %s\n",dgotext)

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

# line 23 "dg_options.l"
		{ ECHO; ddm = 1; 
								strncpy( ddmn, &dgotext[4], dgoleng - 4 );
								ddmn[dgoleng-4] = '\0'; }
break;
case 2:

# line 26 "dg_options.l"
		{ ECHO; rdm = 1; 
								strncpy( rdmn, &dgotext[4], dgoleng - 4 );
								rdmn[dgoleng-4] = '\0'; }
break;
case 3:

# line 29 "dg_options.l"
		{ ECHO; mxp = 1; 
								strncpy( mxpn, &dgotext[8], dgoleng - 8 );
								mxpn[dgoleng-8] = '\0'; }
break;
case 4:

# line 32 "dg_options.l"
		{ ECHO; dmm = 1; 
								strncpy( dmmn, &dgotext[4], dgoleng - 4 );
								dmmn[dgoleng-4] = '\0'; }
break;
case 5:

# line 35 "dg_options.l"
		{ ECHO; rmm = 1; 
								strncpy( rmmn, &dgotext[4], dgoleng - 4 );
								rmmn[dgoleng-4] = '\0'; }
break;
case 6:

# line 38 "dg_options.l"
		{ ECHO; majorize_opt = 1; niter = atoi( &dgotext[9] ); }
break;
case 7:

# line 39 "dg_options.l"
		{ ECHO; gdist = atoi( &dgotext[6] ); }
break;
case 8:

# line 40 "dg_options.l"
		{ ECHO; seed = atoi( &dgotext[5] ); }
break;
case 9:

# line 41 "dg_options.l"
{ ECHO; randpair = atof( &dgotext[9] ); }
break;
case 10:

# line 42 "dg_options.l"
			{ ECHO; ntpr = atoi( &dgotext[5] ); }
break;
case 11:

# line 43 "dg_options.l"
		{ ECHO; eamax = atoi( &dgotext[6] ); }
break;
case 12:

# line 44 "dg_options.l"
	{ ECHO; kchi  = atof( &dgotext[5] ); }
break;
case 13:

# line 45 "dg_options.l"
	{ ECHO; k4d  = atof( &dgotext[4] ); }
break;
case 14:

# line 46 "dg_options.l"
{ ECHO; lbpen  = atof( &dgotext[6] ); }
break;
case 15:

# line 47 "dg_options.l"
{ ECHO; pencut  = atof( &dgotext[7] ); }
break;
case 16:

# line 48 "dg_options.l"
{ ECHO; slearn  = atof( &dgotext[7] ); }
break;
case 17:

# line 49 "dg_options.l"
			{ ECHO; sqviol = atof( &dgotext[7] ); }
break;
case 18:

# line 50 "dg_options.l"
			{ ECHO; pembed = atoi( &dgotext[7] ); }
break;
case 19:

# line 51 "dg_options.l"
		{ ECHO; shuffle = atoi( &dgotext[8] ); }
break;
case 20:

# line 52 "dg_options.l"
	{ ECHO; rbox  = atof( &dgotext[5] ); }
break;
case 21:

# line 53 "dg_options.l"
		{ ECHO; riter = atoi( &dgotext[6] ); }
break;
case 22:

# line 55 "dg_options.l"
					;
break;
case 23:

# line 57 "dg_options.l"
					{	
		fprintf( stderr, "unknown option: %s\n", --gopts );
		exit( 1 );
	}
break;
case -1:
break;
default:
(void)fprintf(dgoout,"bad switch dgolook %d",nstr);
} return(0); }
/* end of dgolex */

# line 63 "dg_options.l"

int dgowrap(){
	return( 1 );
}

#ifdef flex


int  dgo_dgoinput( buf, max_size )

char *buf;
int  max_size;
{
	int n;

	if( max_size > &gopts[dgoinputlim] - dgoinputptr )
		n =  &gopts[dgoinputlim] - dgoinputptr;
	else
		n = max_size;

	if( n>0 ){
		memcpy( buf, dgoinputptr, n );
		dgoinputptr += n;
	}
	return n;
}

#endif
int dgovstop[] = {
0,

23,
0, 

22,
23,
0, 

22,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

23,
0, 

1,
0, 

4,
0, 

13,
0, 

2,
0, 

5,
0, 

12,
0, 

10,
0, 

20,
0, 

8,
0, 

11,
0, 

7,
0, 

14,
0, 

21,
0, 

18,
0, 

15,
0, 

16,
0, 

17,
0, 

3,
0, 

19,
0, 

6,
0, 

9,
0, 
0};
# define YYTYPE unsigned char
struct dgowork { YYTYPE verify, advance; } dgocrank[] = {
0,0,	0,0,	1,3,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	1,4,	1,5,	
4,5,	4,5,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	78,0,	
78,0,	79,0,	79,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	1,4,	36,57,	4,5,	
37,58,	40,61,	50,71,	52,73,	
62,83,	66,87,	70,91,	74,95,	
1,3,	1,4,	78,0,	4,5,	
79,0,	1,3,	80,99,	1,3,	
81,100,	9,20,	84,102,	121,130,	
121,130,	0,0,	78,0,	0,0,	
79,0,	0,0,	1,3,	36,57,	
0,0,	37,58,	40,61,	50,71,	
52,73,	62,83,	66,87,	70,91,	
74,95,	127,135,	127,135,	133,139,	
133,139,	0,0,	0,0,	80,99,	
0,0,	81,100,	0,0,	84,102,	
87,105,	87,105,	87,105,	87,105,	
87,105,	87,105,	87,105,	87,105,	
87,105,	87,105,	0,0,	0,0,	
0,0,	0,0,	7,18,	10,22,	
9,21,	1,6,	1,7,	6,16,	
1,8,	8,19,	13,26,	19,39,	
1,9,	1,10,	1,11,	1,12,	
6,17,	1,13,	16,36,	1,14,	
1,15,	2,6,	2,7,	11,23,	
2,8,	12,25,	17,37,	11,24,	
2,9,	2,10,	2,11,	2,12,	
18,38,	2,13,	20,40,	2,14,	
2,15,	14,27,	14,28,	15,32,	
14,29,	21,41,	15,33,	22,42,	
23,43,	14,30,	15,34,	24,44,	
25,45,	14,31,	27,48,	15,35,	
26,46,	26,47,	28,49,	29,50,	
30,51,	31,52,	32,53,	33,54,	
34,55,	35,56,	38,59,	39,60,	
41,62,	42,63,	43,64,	44,65,	
45,66,	46,67,	47,68,	48,69,	
49,70,	51,72,	53,74,	54,75,	
55,76,	56,77,	57,78,	59,80,	
60,81,	58,79,	63,84,	64,85,	
65,86,	67,88,	57,0,	57,0,	
68,89,	58,0,	58,0,	61,82,	
69,90,	61,82,	61,82,	72,93,	
61,82,	61,82,	61,82,	61,82,	
61,82,	61,82,	61,82,	61,82,	
61,82,	61,82,	75,96,	76,97,	
77,98,	57,0,	85,103,	86,104,	
58,0,	88,106,	89,107,	90,108,	
96,113,	61,82,	93,110,	97,114,	
57,78,	57,0,	98,115,	58,79,	
58,0,	57,78,	71,92,	57,78,	
58,79,	103,119,	58,79,	92,0,	
92,0,	104,120,	71,0,	71,0,	
73,94,	108,123,	57,78,	94,0,	
94,0,	58,79,	106,121,	107,122,	
73,0,	73,0,	113,125,	93,110,	
114,126,	61,82,	119,128,	115,127,	
120,129,	123,132,	92,0,	125,133,	
0,0,	71,0,	128,136,	132,138,	
0,0,	0,0,	94,0,	0,0,	
0,0,	0,0,	92,0,	73,0,	
71,92,	71,0,	0,0,	106,121,	
107,122,	71,92,	94,0,	71,92,	
0,0,	114,126,	73,94,	73,0,	
115,127,	120,129,	0,0,	73,94,	
125,133,	73,94,	71,92,	128,136,	
132,138,	137,0,	137,0,	0,0,	
83,101,	0,0,	83,101,	83,101,	
73,94,	83,101,	83,101,	83,101,	
83,101,	83,101,	83,101,	83,101,	
83,101,	83,101,	83,101,	0,0,	
0,0,	0,0,	0,0,	0,0,	
137,0,	0,0,	91,109,	0,0,	
91,109,	91,109,	83,101,	91,109,	
91,109,	91,109,	91,109,	91,109,	
91,109,	91,109,	91,109,	91,109,	
91,109,	99,116,	99,116,	99,116,	
99,116,	99,116,	99,116,	99,116,	
99,116,	99,116,	99,116,	0,0,	
91,109,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
95,111,	0,0,	83,101,	95,112,	
95,112,	95,112,	95,112,	95,112,	
95,112,	95,112,	95,112,	95,112,	
95,112,	100,117,	100,117,	100,117,	
100,117,	100,117,	100,117,	100,117,	
100,117,	100,117,	100,117,	102,118,	
91,109,	102,118,	102,118,	0,0,	
102,118,	102,118,	102,118,	102,118,	
102,118,	102,118,	102,118,	102,118,	
102,118,	102,118,	110,124,	110,124,	
110,124,	110,124,	110,124,	110,124,	
110,124,	110,124,	110,124,	110,124,	
0,0,	102,118,	111,112,	111,112,	
111,112,	111,112,	111,112,	111,112,	
111,112,	111,112,	111,112,	111,112,	
122,131,	0,0,	122,131,	122,131,	
0,0,	122,131,	122,131,	122,131,	
122,131,	122,131,	122,131,	122,131,	
122,131,	122,131,	122,131,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	102,118,	126,134,	0,0,	
126,134,	126,134,	122,131,	126,134,	
126,134,	126,134,	126,134,	126,134,	
126,134,	126,134,	126,134,	126,134,	
126,134,	0,0,	0,0,	0,0,	
0,0,	129,137,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
126,134,	129,0,	129,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	122,131,	136,140,	
136,140,	136,140,	136,140,	136,140,	
136,140,	136,140,	136,140,	136,140,	
136,140,	0,0,	0,0,	0,0,	
129,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
126,134,	0,0,	0,0,	129,137,	
129,137,	0,0,	0,0,	0,0,	
129,137,	0,0,	129,137,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	138,141,	0,0,	138,141,	
138,141,	129,137,	138,141,	138,141,	
138,141,	138,141,	138,141,	138,141,	
138,141,	138,141,	138,141,	138,141,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	0,0,	
0,0,	0,0,	0,0,	138,141,	
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,	138,141,	
0,0};
struct dgosvf dgosvec[] = {
0,	0,	0,
dgocrank+-1,	0,		0,	
dgocrank+-17,	dgosvec+1,	0,	
dgocrank+0,	0,		dgovstop+1,
dgocrank+3,	0,		dgovstop+3,
dgocrank+0,	dgosvec+4,	dgovstop+6,
dgocrank+3,	0,		dgovstop+8,
dgocrank+1,	0,		dgovstop+10,
dgocrank+5,	0,		dgovstop+12,
dgocrank+1,	0,		dgovstop+14,
dgocrank+1,	0,		dgovstop+16,
dgocrank+22,	0,		dgovstop+18,
dgocrank+5,	0,		dgovstop+20,
dgocrank+5,	0,		dgovstop+22,
dgocrank+36,	0,		dgovstop+24,
dgocrank+34,	0,		dgovstop+26,
dgocrank+5,	0,		0,	
dgocrank+13,	0,		0,	
dgocrank+19,	0,		0,	
dgocrank+2,	0,		0,	
dgocrank+30,	0,		0,	
dgocrank+33,	0,		0,	
dgocrank+27,	0,		0,	
dgocrank+34,	0,		0,	
dgocrank+27,	0,		0,	
dgocrank+32,	0,		0,	
dgocrank+39,	0,		0,	
dgocrank+36,	0,		0,	
dgocrank+39,	0,		0,	
dgocrank+42,	0,		0,	
dgocrank+36,	0,		0,	
dgocrank+44,	0,		0,	
dgocrank+53,	0,		0,	
dgocrank+38,	0,		0,	
dgocrank+55,	0,		0,	
dgocrank+39,	0,		0,	
dgocrank+2,	0,		0,	
dgocrank+4,	0,		0,	
dgocrank+61,	0,		0,	
dgocrank+44,	0,		0,	
dgocrank+5,	0,		0,	
dgocrank+55,	0,		0,	
dgocrank+60,	0,		0,	
dgocrank+51,	0,		0,	
dgocrank+49,	0,		0,	
dgocrank+50,	0,		0,	
dgocrank+67,	0,		0,	
dgocrank+67,	0,		0,	
dgocrank+67,	0,		0,	
dgocrank+48,	0,		0,	
dgocrank+6,	0,		0,	
dgocrank+68,	0,		0,	
dgocrank+7,	0,		0,	
dgocrank+70,	0,		0,	
dgocrank+69,	0,		0,	
dgocrank+75,	0,		0,	
dgocrank+68,	0,		0,	
dgocrank+-173,	0,		0,	
dgocrank+-176,	0,		0,	
dgocrank+55,	0,		0,	
dgocrank+60,	0,		0,	
dgocrank+144,	0,		0,	
dgocrank+8,	0,		0,	
dgocrank+68,	0,		0,	
dgocrank+65,	0,		0,	
dgocrank+75,	0,		0,	
dgocrank+9,	0,		0,	
dgocrank+80,	0,		0,	
dgocrank+67,	0,		0,	
dgocrank+76,	0,		0,	
dgocrank+10,	0,		0,	
dgocrank+-221,	0,		0,	
dgocrank+77,	0,		0,	
dgocrank+-231,	0,		0,	
dgocrank+11,	0,		0,	
dgocrank+100,	0,		0,	
dgocrank+89,	0,		0,	
dgocrank+93,	0,		0,	
dgocrank+-14,	dgosvec+57,	dgovstop+28,
dgocrank+-16,	dgosvec+58,	dgovstop+30,
dgocrank+18,	0,		0,	
dgocrank+20,	0,		0,	
dgocrank+0,	dgosvec+61,	dgovstop+32,
dgocrank+245,	0,		0,	
dgocrank+22,	0,		0,	
dgocrank+101,	0,		0,	
dgocrank+85,	0,		0,	
dgocrank+36,	0,		0,	
dgocrank+109,	0,		0,	
dgocrank+94,	0,		0,	
dgocrank+114,	0,		0,	
dgocrank+267,	0,		0,	
dgocrank+-218,	dgosvec+71,	dgovstop+34,
dgocrank+182,	0,		0,	
dgocrank+-226,	dgosvec+73,	dgovstop+36,
dgocrank+299,	0,		0,	
dgocrank+104,	0,		0,	
dgocrank+105,	0,		0,	
dgocrank+110,	0,		0,	
dgocrank+277,	0,		0,	
dgocrank+309,	0,		0,	
dgocrank+0,	dgosvec+83,	dgovstop+38,
dgocrank+324,	0,		0,	
dgocrank+103,	0,		0,	
dgocrank+128,	0,		0,	
dgocrank+0,	dgosvec+87,	dgovstop+40,
dgocrank+206,	0,		0,	
dgocrank+207,	0,		0,	
dgocrank+128,	0,		0,	
dgocrank+0,	dgosvec+91,	dgovstop+42,
dgocrank+334,	0,		0,	
dgocrank+346,	0,		0,	
dgocrank+0,	dgosvec+111,	dgovstop+44,
dgocrank+141,	0,		0,	
dgocrank+212,	0,		0,	
dgocrank+215,	0,		0,	
dgocrank+0,	dgosvec+99,	dgovstop+46,
dgocrank+0,	dgosvec+100,	dgovstop+48,
dgocrank+0,	dgosvec+102,	dgovstop+50,
dgocrank+145,	0,		0,	
dgocrank+216,	0,		0,	
dgocrank+7,	0,		0,	
dgocrank+361,	0,		0,	
dgocrank+135,	0,		0,	
dgocrank+0,	dgosvec+110,	dgovstop+52,
dgocrank+219,	0,		0,	
dgocrank+383,	0,		0,	
dgocrank+25,	0,		0,	
dgocrank+222,	0,		0,	
dgocrank+-444,	0,		0,	
dgocrank+0,	0,		dgovstop+54,
dgocrank+0,	dgosvec+122,	dgovstop+56,
dgocrank+223,	0,		0,	
dgocrank+27,	0,		0,	
dgocrank+0,	dgosvec+126,	dgovstop+58,
dgocrank+0,	0,		dgovstop+60,
dgocrank+415,	0,		0,	
dgocrank+-276,	dgosvec+129,	dgovstop+62,
dgocrank+458,	0,		0,	
dgocrank+0,	0,		dgovstop+64,
dgocrank+0,	dgosvec+136,	dgovstop+66,
dgocrank+0,	dgosvec+138,	dgovstop+68,
0,	0,	0};
struct dgowork *dgotop = dgocrank+559;
struct dgosvf *dgobgin = dgosvec+1;
char dgomatch[] = {
  0,   1,   1,   1,   1,   1,   1,   1, 
  1,   9,  10,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
 32,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,  43,  44,  43,  43,   1, 
 48,  48,  50,  50,  50,  50,  50,  50, 
 50,  50,   1,   1,   1,  61,   1,   1, 
  1,   1,   1,   1,   1,  43,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,  43,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  1,   1,   1,   1,   1,   1,   1,   1, 
  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 dgoextra[] = {
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 dgolineno =1;
# define YYU(x) x
# define NLSTATE dgoprevious=YYNEWLINE
struct dgosvf *dgolstate [YYLMAX], **dgolsp, **dgoolsp;
char dgosbuf[YYLMAX];
char *dgosptr = dgosbuf;
int *dgofnd;
extern struct dgosvf *dgoestate;
int dgoprevious = YYNEWLINE;
#if defined(__cplusplus) || defined(__STDC__)
int dgolook(void)
#else
dgolook()
#endif
{
	register struct dgosvf *dgostate, **lsp;
	register struct dgowork *dgot;
	struct dgosvf *dgoz;
	int dgoch, dgofirst;
	struct dgowork *dgor;
# ifdef LEXDEBUG
	int debug;
# endif
	char *dgolastch;
	/* start off machines */
# ifdef LEXDEBUG
	debug = 0;
# endif
	dgofirst=1;
	if (!dgomorfg)
		dgolastch = dgotext;
	else {
		dgomorfg=0;
		dgolastch = dgotext+dgoleng;
		}
	for(;;){
		lsp = dgolstate;
		dgoestate = dgostate = dgobgin;
		if (dgoprevious==YYNEWLINE) dgostate++;
		for (;;){
# ifdef LEXDEBUG
			if(debug)fprintf(dgoout,"state %d\n",dgostate-dgosvec-1);
# endif
			dgot = dgostate->dgostoff;
			if(dgot == dgocrank && !dgofirst){  /* may not be any transitions */
				dgoz = dgostate->dgoother;
				if(dgoz == 0)break;
				if(dgoz->dgostoff == dgocrank)break;
				}
#ifndef __cplusplus
			*dgolastch++ = dgoch = input();
#else
			*dgolastch++ = dgoch = lex_input();
#endif
#ifdef YYISARRAY
			if(dgolastch > &dgotext[YYLMAX]) {
				fprintf(dgoout,"Input string too long, limit %d\n",YYLMAX);
				exit(1);
			}
#else
			if (dgolastch >= &dgotext[ dgotextsz ]) {
				int	x = dgolastch - dgotext;

				dgotextsz += YYTEXTSZINC;
				if (dgotext == dgo_tbuf) {
				    dgotext = (char *) malloc(dgotextsz);
				    memcpy(dgotext, dgo_tbuf, sizeof (dgo_tbuf));
				}
				else
				    dgotext = (char *) realloc(dgotext, dgotextsz);
				if (!dgotext) {
				    fprintf(dgoout,
					"Cannot realloc dgotext\n");
				    exit(1);
				}
				dgolastch = dgotext + x;
			}
#endif
			dgofirst=0;
		tryagain:
# ifdef LEXDEBUG
			if(debug){
				fprintf(dgoout,"char ");
				allprint(dgoch);
				putchar('\n');
				}
# endif
			dgor = dgot;
			if ( (uintptr_t)dgot > (uintptr_t)dgocrank){
				dgot = dgor + dgoch;
				if (dgot <= dgotop && dgot->verify+dgosvec == dgostate){
					if(dgot->advance+dgosvec == YYLERR)	/* error transitions */
						{unput(*--dgolastch);break;}
					*lsp++ = dgostate = dgot->advance+dgosvec;
					if(lsp > &dgolstate[YYLMAX]) {
						fprintf(dgoout,"Input string too long, limit %d\n",YYLMAX);
						exit(1);
					}
					goto contin;
					}
				}
# ifdef YYOPTIM
			else if((uintptr_t)dgot < (uintptr_t)dgocrank) {	/* r < dgocrank */
				dgot = dgor = dgocrank+(dgocrank-dgot);
# ifdef LEXDEBUG
				if(debug)fprintf(dgoout,"compressed state\n");
# endif
				dgot = dgot + dgoch;
				if(dgot <= dgotop && dgot->verify+dgosvec == dgostate){
					if(dgot->advance+dgosvec == YYLERR)	/* error transitions */
						{unput(*--dgolastch);break;}
					*lsp++ = dgostate = dgot->advance+dgosvec;
					if(lsp > &dgolstate[YYLMAX]) {
						fprintf(dgoout,"Input string too long, limit %d\n",YYLMAX);
						exit(1);
					}
					goto contin;
					}
				dgot = dgor + YYU(dgomatch[dgoch]);
# ifdef LEXDEBUG
				if(debug){
					fprintf(dgoout,"try fall back character ");
					allprint(YYU(dgomatch[dgoch]));
					putchar('\n');
					}
# endif
				if(dgot <= dgotop && dgot->verify+dgosvec == dgostate){
					if(dgot->advance+dgosvec == YYLERR)	/* error transition */
						{unput(*--dgolastch);break;}
					*lsp++ = dgostate = dgot->advance+dgosvec;
					if(lsp > &dgolstate[YYLMAX]) {
						fprintf(dgoout,"Input string too long, limit %d\n",YYLMAX);
						exit(1);
					}
					goto contin;
					}
				}
			if ((dgostate = dgostate->dgoother) && (dgot= dgostate->dgostoff) != dgocrank){
# ifdef LEXDEBUG
				if(debug)fprintf(dgoout,"fall back to state %d\n",dgostate-dgosvec-1);
# endif
				goto tryagain;
				}
# endif
			else
				{unput(*--dgolastch);break;}
		contin:
# ifdef LEXDEBUG
			if(debug){
				fprintf(dgoout,"state %d char ",dgostate-dgosvec-1);
				allprint(dgoch);
				putchar('\n');
				}
# endif
			;
			}
# ifdef LEXDEBUG
		if(debug){
			fprintf(dgoout,"stopped at %d with ",*(lsp-1)-dgosvec-1);
			allprint(dgoch);
			putchar('\n');
			}
# endif
		while (lsp-- > dgolstate){
			*dgolastch-- = 0;
			if (*lsp != 0 && (dgofnd= (*lsp)->dgostops) && *dgofnd > 0){
				dgoolsp = lsp;
				if(dgoextra[*dgofnd]){		/* must backup */
					while(dgoback((*lsp)->dgostops,-*dgofnd) != 1 && lsp > dgolstate){
						lsp--;
						unput(*dgolastch--);
						}
					}
				dgoprevious = YYU(*dgolastch);
				dgolsp = lsp;
				dgoleng = dgolastch-dgotext+1;
				dgotext[dgoleng] = 0;
# ifdef LEXDEBUG
				if(debug){
					fprintf(dgoout,"\nmatch ");
					sprint(dgotext);
					fprintf(dgoout," action %d\n",*dgofnd);
					}
# endif
				return(*dgofnd++);
				}
			unput(*dgolastch);
			}
		if (dgotext[0] == 0  /* && feof(dgoin) */)
			{
			dgosptr=dgosbuf;
			return(0);
			}
#ifndef __cplusplus
		dgoprevious = dgotext[0] = input();
		if (dgoprevious>0)
			output(dgoprevious);
#else
		dgoprevious = dgotext[0] = lex_input();
		if (dgoprevious>0)
			lex_output(dgoprevious);
#endif
		dgolastch=dgotext;
# ifdef LEXDEBUG
		if(debug)putchar('\n');
# endif
		}
	}
#if defined(__cplusplus) || defined(__STDC__)
int dgoback(int *p, int m)
#else
dgoback(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 dgoinput(void)
#else
dgoinput()
#endif
{
#ifndef __cplusplus
	return(input());
#else
	return(lex_input());
#endif
	}
#if defined(__cplusplus) || defined(__STDC__)
void dgooutput(int c)
#else
dgooutput(c)
  int c; 
#endif
{
#ifndef __cplusplus
	output(c);
#else
	lex_output(c);
#endif
	}
#if defined(__cplusplus) || defined(__STDC__)
void dgounput(int c)
#else
dgounput(c)
   int c; 
#endif
{
	unput(c);
	}