#ifndef YY_READ_BUF_SIZE#define YY_READ_BUF_SIZE 8192#endif/* Copy whatever the last rule matched to the standard output. */#ifndef ECHO/* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */#define ECHO fwrite( lpt_yytext, lpt_yyleng, 1, lpt_yyout )#endif/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL, * is returned in "result". */#ifndef YY_INPUT#define YY_INPUT(buf,result,max_size) \	if ( YY_CURRENT_BUFFER_LVALUE->lpt_yy_is_interactive ) \		{ \		int c = '*'; \		int n; \		for ( n = 0; n < max_size && \			     (c = getc( lpt_yyin )) != EOF && c != '\n'; ++n ) \			buf[n] = (char) c; \		if ( c == '\n' ) \			buf[n++] = (char) c; \		if ( c == EOF && ferror( lpt_yyin ) ) \			YY_FATAL_ERROR( "input in flex scanner failed" ); \		result = n; \		} \	else \		{ \		errno=0; \		while ( (result = fread(buf, 1, max_size, lpt_yyin))==0 && ferror(lpt_yyin)) \			{ \			if( errno != EINTR) \				{ \				YY_FATAL_ERROR( "input in flex scanner failed" ); \				break; \				} \			errno=0; \			clearerr(lpt_yyin); \			} \		}\\#endif/* No semi-colon after return; correct usage is to write "lpt_yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */#ifndef lpt_yyterminate#define lpt_yyterminate() return YY_NULL#endif/* Number of entries by which start-condition stack grows. */#ifndef YY_START_STACK_INCR#define YY_START_STACK_INCR 25#endif/* Report a fatal error. */#ifndef YY_FATAL_ERROR#define YY_FATAL_ERROR(msg) lpt_yy_fatal_error( msg , lpt_yyscanner)#endif/* end tables serialization structures and prototypes *//* Default declaration of generated scanner - a define so the user can * easily add parameters. */#ifndef YY_DECL#define YY_DECL_IS_OURS 1extern int lpt_yylex \               (YYSTYPE * lpt_yylval_param ,lpt_yyscan_t lpt_yyscanner);#define YY_DECL int lpt_yylex \               (YYSTYPE * lpt_yylval_param , lpt_yyscan_t lpt_yyscanner)#endif /* !YY_DECL *//* Code executed at the beginning of each rule, after lpt_yytext and lpt_yyleng * have been set up. */#ifndef YY_USER_ACTION#define YY_USER_ACTION#endif/* Code executed at the end of each rule. */#ifndef YY_BREAK#define YY_BREAK break;#endif#define YY_RULE_SETUP \	if ( lpt_yyleng > 0 ) \		YY_CURRENT_BUFFER_LVALUE->lpt_yy_at_bol = \				(lpt_yytext[lpt_yyleng - 1] == '\n'); \	YY_USER_ACTION/** The main scanner function which does all the work. */YY_DECL{	register lpt_yy_state_type lpt_yy_current_state;	register char *lpt_yy_cp, *lpt_yy_bp;	register int lpt_yy_act;    struct lpt_yyguts_t * lpt_yyg = (struct lpt_yyguts_t*)lpt_yyscanner;    lpt_yylval = lpt_yylval_param;	if ( !lpt_yyg->lpt_yy_init )		{		lpt_yyg->lpt_yy_init = 1;#ifdef YY_USER_INIT		YY_USER_INIT;#endif		if ( ! lpt_yyg->lpt_yy_start )			lpt_yyg->lpt_yy_start = 1;	/* first start state */		if ( ! lpt_yyin )			lpt_yyin = stdin;		if ( ! lpt_yyout )			lpt_yyout = stdout;		if ( ! YY_CURRENT_BUFFER ) {			lpt_yyensure_buffer_stack (lpt_yyscanner);			YY_CURRENT_BUFFER_LVALUE =				lpt_yy_create_buffer(lpt_yyin,YY_BUF_SIZE ,lpt_yyscanner);		}		lpt_yy_load_buffer_state(lpt_yyscanner );		}	while ( 1 )		/* loops until end-of-file is reached */		{		lpt_yy_cp = lpt_yyg->lpt_yy_c_buf_p;		/* Support of lpt_yytext. */		*lpt_yy_cp = lpt_yyg->lpt_yy_hold_char;		/* lpt_yy_bp points to the position in lpt_yy_ch_buf of the start of		 * the current run.		 */		lpt_yy_bp = lpt_yy_cp;		lpt_yy_current_state = lpt_yyg->lpt_yy_start;		lpt_yy_current_state += YY_AT_BOL();lpt_yy_match:		do			{			register YY_CHAR lpt_yy_c = lpt_yy_ec[YY_SC_TO_UI(*lpt_yy_cp)];			if ( lpt_yy_accept[lpt_yy_current_state] )				{				lpt_yyg->lpt_yy_last_accepting_state = lpt_yy_current_state;				lpt_yyg->lpt_yy_last_accepting_cpos = lpt_yy_cp;				}			while ( lpt_yy_chk[lpt_yy_base[lpt_yy_current_state] + lpt_yy_c] != lpt_yy_current_state )				{				lpt_yy_current_state = (int) lpt_yy_def[lpt_yy_current_state];				if ( lpt_yy_current_state >= 174 )					lpt_yy_c = lpt_yy_meta[(unsigned int) lpt_yy_c];				}			lpt_yy_current_state = lpt_yy_nxt[lpt_yy_base[lpt_yy_current_state] + (unsigned int) lpt_yy_c];			++lpt_yy_cp;			}		while ( lpt_yy_base[lpt_yy_current_state] != 716 );lpt_yy_find_action:		lpt_yy_act = lpt_yy_accept[lpt_yy_current_state];		if ( lpt_yy_act == 0 )			{ /* have to back up */			lpt_yy_cp = lpt_yyg->lpt_yy_last_accepting_cpos;			lpt_yy_current_state = lpt_yyg->lpt_yy_last_accepting_state;			lpt_yy_act = lpt_yy_accept[lpt_yy_current_state];			}		YY_DO_BEFORE_ACTION;		if ( lpt_yy_act != YY_END_OF_BUFFER && lpt_yy_rule_can_match_eol[lpt_yy_act] )			{			int lpt_yyl;			for ( lpt_yyl = 0; lpt_yyl < lpt_yyleng; ++lpt_yyl )				if ( lpt_yytext[lpt_yyl] == '\n' )					       do{ lpt_yylineno++;        lpt_yycolumn=0;    }while(0);			}do_action:	/* This label is used only to access EOF actions. */		switch ( lpt_yy_act )	{ /* beginning of action switch */			case 0: /* must back up */			/* undo the effects of YY_DO_BEFORE_ACTION */			*lpt_yy_cp = lpt_yyg->lpt_yy_hold_char;			lpt_yy_cp = lpt_yyg->lpt_yy_last_accepting_cpos;			lpt_yy_current_state = lpt_yyg->lpt_yy_last_accepting_state;			goto lpt_yy_find_action;case 1:YY_RULE_SETUP{  BEGIN LINECOMMENT;} /* begin skip LINECOMMENT */	YY_BREAKcase 2:/* rule 2 can match eol */YY_RULE_SETUP{  BEGIN INITIAL;} /* end skip LINECOMMENT */	YY_BREAKcase 3:YY_RULE_SETUP{  BEGIN INITIAL;} /* end skip LINECOMMENT */	YY_BREAKcase 4:YY_RULE_SETUP{}	YY_BREAKcase 5:/* rule 5 can match eol */YY_RULE_SETUP{}	YY_BREAKcase 6:YY_RULE_SETUP{  parse_parm *pp = PARM;  pp->lineno = lpt_yylineno;  return(MINIMISE);}	YY_BREAKcase 7:YY_RULE_SETUP{  parse_parm *pp = PARM;  pp->lineno = lpt_yylineno;  return(MAXIMISE);}	YY_BREAKcase 8:YY_RULE_SETUP{  parse_parm *pp = PARM;  pp->lineno = lpt_yylineno;  return(SUBJECTTO);}	YY_BREAKcase 9:YY_RULE_SETUP{  parse_parm *pp = PARM;  pp->lineno = lpt_yylineno;  return(BOUNDS);}	YY_BREAKcase 10:YY_RULE_SETUP{  parse_parm *pp = PARM;  pp->lineno = lpt_yylineno;  return(END);}	YY_BREAKcase 11:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char *ptr = (char *)lpt_yytext;  pp->lineno = lpt_yylineno;  while ((isspace(*ptr))) ptr++;  pv->f = atof(ptr);  return(INTCONS);} /* f contains the last float */	YY_BREAKcase 12:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char *ptr = (char *)lpt_yytext;  pp->lineno = lpt_yylineno;  while ((isspace(*ptr))) ptr++;  pv->f = atof(ptr);  return(CONS);} /* f contains the last float */	YY_BREAKcase 13:/* rule 13 can match eol */YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char *ptr = (char *)lpt_yytext;  pp->lineno = lpt_yylineno;  pv->f = DEF_INFINITE;  pv->Sign = 0;  while (isspace(*ptr)) ptr++;  if(*ptr == '-')    pv->Sign = 1;  return(INF);} /* f contains the last float */	YY_BREAKcase 14:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char *ptr = (char *)lpt_yytext;  pp->lineno = lpt_yylineno;  while ((isspace(*ptr))) ptr++;  FREE(pv->Last_var);  pv->Last_var = strdup(ptr);  return(FRE);}	YY_BREAKcase 15:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  int x;  pp->lineno = lpt_yylineno;  pv->Sign = 0;  for(x = 0; x < lpt_yyleng; x++)    if(lpt_yytext[x] == '-' || lpt_yytext[x] == '+')      pv->Sign = (pv->Sign == (lpt_yytext[x] == '+'));  return (TOK_SIGN);  /* Sign is TRUE if the sign-string     represents a '-'. Otherwise Sign     is FALSE */}	YY_BREAKcase 16:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char *ptr = (char *)lpt_yytext;  pp->lineno = lpt_yylineno;  while ((isspace(*ptr))) ptr++;  pv->Within_gen_decl = pv->Within_bin_decl = pv->Within_sec_decl = pv->Within_sos_decl = FALSE;  if((toupper(*ptr) == 'G') || (toupper(*ptr) == 'I'))    pv->Within_gen_decl = TRUE;  else    pv->Within_bin_decl = TRUE;  return(SEC_INT);}	YY_BREAKcase 17:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pp->lineno = lpt_yylineno;  pv->Within_gen_decl = pv->Within_bin_decl = pv->Within_sec_decl = pv->Within_sos_decl = FALSE;  pv->Within_sec_decl = TRUE;  return(SEC_SEC);}	YY_BREAKcase 18:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  pp->lineno = lpt_yylineno;  pv->Within_gen_decl = pv->Within_bin_decl = pv->Within_sec_decl = pv->Within_sos_decl = FALSE;  pv->Within_sos_decl = TRUE;  return(SEC_SOS);}	YY_BREAKcase 19:YY_RULE_SETUP{  parse_parm *pp = PARM;  parse_vars *pv = (parse_vars *) pp->parse_vars;  char *ptr = (char *)lpt_yytext;  pp->lineno = lpt_yylineno;  while ((isspace(*ptr))) ptr++;  FREE(pv->Last_var);