# 1 "y.tab.c" 
extern char *malloc(), *realloc();

int bug;
int dbug;
int crlycnt;
int inplayer, first_inst;
int parencnt, countparens;
int *getout();
int m_start_seen, t_start_seen;
long foo;
char *scpy();
char *getpnum();
char white[];

# 1 "/usr/include/stdio.h" 1





extern	struct	_iobuf {
	int	_cnt;
	unsigned char *_ptr;
	unsigned char *_base;
	int	_bufsiz;
	short	_flag;
	char	_file;		
} _iob[];



















# 36 "/usr/include/stdio.h" 

















extern struct _iobuf	*fopen();
extern struct _iobuf	*fdopen();
extern struct _iobuf	*freopen();
extern struct _iobuf	*popen();
extern struct _iobuf	*tmpfile();
extern long	ftell();
extern char	*fgets();
extern char	*gets();
extern char	*sprintf();
extern char	*ctermid();
extern char	*cuserid();
extern char	*tempnam();
extern char	*tmpnam();






# 16 "y.tab.c" 2
# 1 "/usr/include/ctype.h" 1












extern	char	_ctype_[];














# 17 "y.tab.c" 2
# 1 "./ymain.h" 1


struct pstruct {
	char	*player;
	char	*begin;
	char	*dur;
	char	*stat;
	char	*cnt;
	int	hi_ref_pn;
	int	rstat;
	int	has_instance_data;
};

extern struct pstruct vs[];
extern int playercnt;
extern char **divert_body, **divert_instance_decl;
extern long divert_body_cnt, divert_instance_decl_cnt;
extern long divert_body_len, divert_instance_decl_len;
long divert(), undivert();
extern int integer;
# 18 "y.tab.c" 2

typedef union  {
	int i;
	char *s;
	} YYSTYPE;







































extern int yychar;
extern int yyerrflag;



YYSTYPE yylval, yyval;




char *
scpy(a)
	int a;
{
	char *tmp;
	int i, *p, len = 0; 
	char **x;

	p = &a;		
	i = *p++;	
	x = (char **) p;
	while (i--) {
		len += strlen(*x++);
	}
	tmp = (char *) malloc(len+1);
	i = a;
	x = (char **) p;
	*tmp = '\0';
	while (i--) {
		strcat(tmp, *x++);
	}
	return(tmp);
}

max(x, y)
	int x, y;
{
	return(x>y ? x : y);
}

char *getpnum(str)
	char *str;
{
	if (((_ctype_+1)[str[1]]&04))	
		str++;
	else
		str += 2;	
	return(str);
}

nl2sp(str)
	char *str;
{
	char *c;

	for (c = str; *c != 0; c++)
		if (*c == '\n')
			*c = ' ';
}
int yyexca[] ={
-1, 0,
	0, 1,
	258, 1,
	259, 1,
	260, 1,
	262, 1,
	263, 1,
	264, 1,
	265, 1,
	266, 1,
	267, 1,
	268, 1,
	269, 1,
	270, 1,
	272, 1,
	273, 1,
	274, 1,
	275, 1,
	276, 1,
	277, 1,
	278, 1,
	279, 1,
	280, 1,
	281, 1,
	282, 1,
	283, 1,
	284, 1,
	285, 1,
	289, 1,
	290, 1,
	291, 1,
	292, 1,
	293, 1,
	-2, 0,
-1, 1,
	0, -1,
	-2, 0,
-1, 6,
	271, 59,
	286, 59,
	288, 59,
	-2, 6,
	};


int yyact[]={

    18,    19,    20,    54,    21,    22,    23,    24,    25,    26,
    27,    28,    36,    58,    29,    30,    31,    32,    33,     6,
    34,    35,    10,    37,    11,    13,    12,    14,    57,    56,
    55,    15,    16,    17,     5,    39,    18,    19,    20,    40,
    21,    22,    23,    24,    25,    26,    27,    28,    36,    45,
    29,    30,    31,    32,    33,    46,    34,    35,    44,    37,
    11,    13,    12,    14,    49,    53,    50,    15,    16,    17,
    18,    19,    20,     2,    21,    22,    23,    24,    25,    26,
    27,    28,    36,    38,    29,    30,    31,    76,    33,    46,
    34,    35,    44,    37,    11,    13,    12,    14,    49,     9,
    50,    15,    16,    17,    18,    19,    20,    48,    21,    22,
    23,    24,    25,    26,    27,    28,    36,    43,    29,    30,
    31,    75,    33,    46,    34,    35,    44,    37,    11,    13,
    12,    14,    49,    47,    50,    15,    16,    17,    18,    19,
    20,     7,    21,    22,    23,    24,    25,    26,    27,    28,
    36,    42,    29,    30,    31,    74,    33,    46,    34,    35,
    44,    37,    11,    13,    12,    14,    49,    62,    50,    15,
    16,    17,    18,    19,    20,     1,    21,    22,    23,    24,
    25,    26,    27,    28,    36,     0,    29,    30,    31,    32,
    33,    46,    34,    35,    63,    37,    11,    13,    12,    14,
     0,     0,     8,    15,    16,    17,    41,    39,    65,    66,
     3,    64,    79,    67,    68,     4,    52,    73,     0,    69,
     0,    51,     0,    70,    77,     0,     0,    71,    72,    65,
    66,     0,    64,     0,    67,    68,     0,     0,    73,     0,
    69,     0,     0,     0,    70,     0,     0,     0,    71,    72,
     0,     0,     0,     0,     0,    41,     0,    78,     0,     0,
     0,     0,    41,    41,    41,     0,    59,    60,    61,     0,
     0,     0,     0,     0,    80 };
int yypact[]={

  -183,  -258,  -232,  -222, -1000,   -86, -1000,  -197, -1000, -1000,
 -1000, -1000, -1000, -1000, -1000,  -273, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,  -244, -1000,
 -1000, -1000, -1000, -1000, -1000, -1000, -1000,  -245,  -246, -1000,
 -1000, -1000,  -222,  -261, -1000,   -86,   -86,   -86,   -30,  -120,
  -154,  -188,   -51, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
 -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,   -30,
 -1000 };
int yypgo[]={

     0,   175,   210,   215,   202,   167,   194,   151,   141,   133,
   117,   107,    99,    83 };
int yyr1[]={

     0,     1,     1,     1,     1,     1,     1,     1,     8,     5,
     5,     5,     5,     6,     6,     6,     6,     6,     6,     6,
     6,     6,     6,     2,     2,     2,     2,     2,     2,     3,
     9,     7,    11,    10,    13,    12,     4,     4,     4,     4,
     4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
     4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
     4,     4,     4,     4 };
int yyr2[]={

     0,     1,     5,     5,     5,     7,     5,    13,     3,     1,
     3,     5,     7,     3,     3,     3,     3,     3,     3,     3,
     3,     3,     3,     3,     5,     5,     5,     3,     5,     5,
     3,     9,     3,     9,     3,     9,     3,     3,     3,     3,
     5,     3,     3,     3,     3,     3,     3,     3,     3,     3,
     3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
     3,     3,     3,     3 };
int yychk[]={

 -1000,    -1,   256,    -2,    -3,   292,   277,    -8,    -4,   -12,
   280,   282,   284,   283,   285,   289,   290,   291,   258,   259,
   260,   262,   263,   264,   265,   266,   267,   268,   269,   272,
   273,   274,   275,   276,   278,   279,   270,   281,   -13,   293,
   271,    -4,    -7,   -10,   280,   271,   277,    -9,   -11,   286,
   288,    -3,    -2,   262,   276,   274,   274,   274,   274,    -2,
    -2,    -2,    -5,    -6,   262,   259,   260,   264,   265,   270,
   274,   278,   279,   268,   275,   275,   275,   275,    -6,   263,
    -6 };
int yydef[]={

    -2,    -2,     0,     3,     4,     0,    -2,     0,    23,    27,
     8,    36,    37,    38,    39,     0,    41,    42,    43,    44,
    45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
    55,    56,    57,    58,    60,    61,    62,    63,     0,    34,
     2,    24,    25,    26,    28,    29,    59,     0,     0,    30,
    32,     5,     0,     0,    40,     0,     0,     0,     9,     0,
     0,     0,     0,    10,    13,    14,    15,    16,    17,    18,
    19,    20,    21,    22,    35,    31,    33,     7,    11,     0,
    12 };
typedef struct { char *t_name; int t_val; } yytoktype;
# 255 "y.tab.c" 




yytoktype yytoks[] =
{
	"LSTART",	257,
	"LPERIOD",	258,
	"LINT",	259,
	"LFLOAT",	260,
	"LWHITE",	261,
	"LSYMBOL",	262,
	"LCOMMA",	263,
	"LOCTAL",	264,
	"LHEX",	265,
	"LQSTR",	266,
	"LBRACKETS",	267,
	"LOP",	268,
	"LQCHR",	269,
	"LARB",	270,
	"LSEMI",	271,
	"LCOMMENT",	272,
	"LERROR",	273,
	"LLPAREN",	274,
	"LRPAREN",	275,
	"LLCRLY",	276,
	"LRCRLY",	277,
	"LLSQB",	278,
	"LRSQB",	279,
	"PLAYER",	280,
	"EXTERN",	281,
	"PNFIELD",	282,
	"PIFIELD",	283,
	"PSFIELD",	284,
	"PPFIELD",	285,
	"CYCLIST",	286,
	"V_ST_REF",	287,
	"GEN",	288,
	"P_START",	289,
	"M_START",	290,
	"M_TER",	291,
	"INSTANCE",	292,
	"MOTIVE",	293,
	"-unknown-",	-1	
};

char * yyreds[] =
{
	"-no such reduction-",
	"start : /* empty */",
	"start : error LSEMI",
	"start : start stat",
	"start : start tstat",
	"start : start INSTANCE tstat",
	"start : start LRCRLY",
	"start : start player LSYMBOL LLPAREN args LRPAREN",
	"player : PLAYER",
	"args : /* empty */",
	"args : arg_obj",
	"args : args arg_obj",
	"args : args LCOMMA arg_obj",
	"arg_obj : LSYMBOL",
	"arg_obj : LINT",
	"arg_obj : LFLOAT",
	"arg_obj : LOCTAL",
	"arg_obj : LHEX",
	"arg_obj : LARB",
	"arg_obj : LLPAREN",
	"arg_obj : LLSQB",
	"arg_obj : LRSQB",
	"arg_obj : LOP",
	"stat : obj",
	"stat : stat obj",
	"stat : stat cycl",
	"stat : stat gen",
	"stat : motive",
	"stat : stat PLAYER",
	"tstat : stat LSEMI",
	"cyclh : CYCLIST",
	"cycl : cyclh LLPAREN stat LRPAREN",
	"genh : GEN",
	"gen : genh LLPAREN stat LRPAREN",
	"motivh : MOTIVE",
	"motive : motivh LLPAREN stat LRPAREN",
	"obj : PNFIELD",
	"obj : PSFIELD",
	"obj : PIFIELD",
	"obj : PPFIELD",
	"obj : P_START LLCRLY",
	"obj : M_START",
	"obj : M_TER",
	"obj : LPERIOD",
	"obj : LINT",
	"obj : LFLOAT",
	"obj : LSYMBOL",
	"obj : LCOMMA",
	"obj : LOCTAL",
	"obj : LHEX",
	"obj : LQSTR",
	"obj : LBRACKETS",
	"obj : LOP",
	"obj : LQCHR",
	"obj : LCOMMENT",
	"obj : LERROR",
	"obj : LLPAREN",
	"obj : LRPAREN",
	"obj : LLCRLY",
	"obj : LRCRLY",
	"obj : LLSQB",
	"obj : LRSQB",
	"obj : LARB",
	"obj : EXTERN",
};

# 1 "/usr/lib/yaccpar"

























# 28 "/usr/lib/yaccpar" 





int yydebug;			









static YYSTYPE *yyv;			
static int *yys;			

static YYSTYPE *yypv;			
static int *yyps;			

static int yystate;			
static int yytmp;			

int yynerrs;			

int yyerrflag;			
int yychar;			





int
yyparse()
{
	register YYSTYPE *yypvt;	
	unsigned yymaxdepth = 150;

	


	yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
	yys = (int*)malloc(yymaxdepth*sizeof(int));
	if (!yyv || !yys)
	{
		yyerror( "out of memory" );
		return(1);
	}
	yypv = &yyv[-1];
	yyps = &yys[-1];
	yystate = 0;
	yytmp = 0;
	yynerrs = 0;
	yyerrflag = 0;
	yychar = -1;

	goto yystack;
	{
		register YYSTYPE *yy_pv;	
		register int *yy_ps;		
		register int yy_state;		
		register int  yy_n;		

		



	yynewstate:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;
		goto yy_newstate;

		



	yystack:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;

		


	yy_stack:
		



		





		if ( yydebug )
		{
			register int yy_i;

			(void)printf( "State %d, token ", yy_state );
			if ( yychar == 0 )
				(void)printf( "end-of-file\n" );
			else if ( yychar < 0 )
				(void)printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				(void)printf( "%s\n", yytoks[yy_i].t_name );
			}
		}

		if ( ++yy_ps >= &yys[ yymaxdepth ] )	
		{
			



			int yyps_index = (yy_ps - yys);
			int yypv_index = (yy_pv - yyv);
			int yypvt_index = (yypvt - yyv);
			yymaxdepth += 150;
			yyv = (YYSTYPE*)realloc((char*)yyv,
				yymaxdepth * sizeof(YYSTYPE));
			yys = (int*)realloc((char*)yys,
				yymaxdepth * sizeof(int));
			if (!yyv || !yys)
			{
				yyerror( "yacc stack overflow" );
				return(1);
			}
			yy_ps = yys + yyps_index;
			yy_pv = yyv + yypv_index;
			yypvt = yyv + yypvt_index;
		}
		*yy_ps = yy_state;
		*++yy_pv = yyval;

		


	yy_newstate:
		if ( ( yy_n = yypact[ yy_state ] ) <= (-1000) )
			goto yydefault;		

		


		yytmp = yychar < 0;

		if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
			yychar = 0;		

		if ( yydebug && yytmp )
		{
			register int yy_i;

			(void)printf( "Received token " );
			if ( yychar == 0 )
				(void)printf( "end-of-file\n" );
			else if ( yychar < 0 )
				(void)printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				(void)printf( "%s\n", yytoks[yy_i].t_name );
			}
		}

		if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= 275 ) )
			goto yydefault;
		if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )	
		{
			yychar = -1;
			yyval = yylval;
			yy_state = yy_n;
			if ( yyerrflag > 0 )
				yyerrflag--;
			goto yy_stack;
		}

	yydefault:
		if ( ( yy_n = yydef[ yy_state ] ) == -2 )
		{

			yytmp = yychar < 0;

			if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
				yychar = 0;		

			if ( yydebug && yytmp )
			{
				register int yy_i;

				(void)printf( "Received token " );
				if ( yychar == 0 )
					(void)printf( "end-of-file\n" );
				else if ( yychar < 0 )
					(void)printf( "-none-\n" );
				else
				{
					for ( yy_i = 0;
						yytoks[yy_i].t_val >= 0;
						yy_i++ )
					{
						if ( yytoks[yy_i].t_val
							== yychar )
						{
							break;
						}
					}
					(void)printf( "%s\n", yytoks[yy_i].t_name );
				}
			}

			


			{
				register int *yyxi = yyexca;

				while ( ( *yyxi != -1 ) ||
					( yyxi[1] != yy_state ) )
				{
					yyxi += 2;
				}
				while ( ( *(yyxi += 2) >= 0 ) &&
					( *yyxi != yychar ) )
					;
				if ( ( yy_n = yyxi[1] ) < 0 )
					{ free(yys); free(yyv); return(0); };
			}
		}

		


		if ( yy_n == 0 )	
		{
			
			switch ( yyerrflag )
			{
			case 0:		
				yyerror( "syntax error" );
				goto skip_init;
			yyerrlab:
				



				yy_pv = yypv;
				yy_ps = yyps;
				yy_state = yystate;
				yynerrs++;
			skip_init:
			case 1:
			case 2:		
					
				yyerrflag = 3;
				



				while ( yy_ps >= yys )
				{
					yy_n = yypact[ *yy_ps ] + 256;
					if ( yy_n >= 0 && yy_n < 275 &&
						yychk[yyact[yy_n]] == 256)					{
						


						yy_state = yyact[ yy_n ];
						goto yy_stack;
					}
					





					if ( yydebug )
						(void)printf( "Error recovery pops state %d, uncovers state %d\n", *yy_ps,
							yy_ps[-1] );


					yy_ps--;
					yy_pv--;
				}
				



				{ free(yys); free(yyv); return(1); };
			case 3:		

				






				if ( yydebug )
				{
					register int yy_i;

					(void)printf( "Error recovery discards " );
					if ( yychar == 0 )
						(void)printf( "token end-of-file\n" );
					else if ( yychar < 0 )
						(void)printf( "token -none-\n" );
					else
					{
						for ( yy_i = 0;
							yytoks[yy_i].t_val >= 0;
							yy_i++ )
						{
							if ( yytoks[yy_i].t_val
								== yychar )
							{
								break;
							}
						}
						(void)printf( "token %s\n",
							yytoks[yy_i].t_name );
					}
				}

				if ( yychar == 0 )	
					{ free(yys); free(yyv); return(1); };
				yychar = -1;
				goto yy_newstate;
			}
		}
		




		




		if ( yydebug )
			(void)printf( "Reduce by (%d) \"%s\"\n",
				yy_n, yyreds[ yy_n ] );

		yytmp = yy_n;			
		yypvt = yy_pv;			
		











		{
			
			register int yy_len = yyr2[ yy_n ];

			if ( !( yy_len & 01 ) )
			{
				yy_len >>= 1;
				yyval = ( yy_pv -= yy_len )[1];	
				yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
					*( yy_ps -= yy_len ) + 1;
				if ( yy_state >= 275 ||
					yychk[ yy_state =
					yyact[ yy_state ] ] != -yy_n )
				{
					yy_state = yyact[ yypgo[ yy_n ] ];
				}
				goto yy_stack;
			}
			yy_len >>= 1;
			yyval = ( yy_pv -= yy_len )[1];	
			yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
				*( yy_ps -= yy_len ) + 1;
			if ( yy_state >= 275 ||
				yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
			{
				yy_state = yyact[ yypgo[ yy_n ] ];
			}
		}
					
		yystate = yy_state;
		yyps = yy_ps;
		yypv = yy_pv;
	}
	


	switch( yytmp )
	{
		
case 1:
{ yyval.s = 0; } break;
case 2:
{} break;
case 3:
{
		if(bug)printf("%s$%s$\n----------\n", 
			"start 1: start stat=\n",
			yypvt[-0].s);
		foo = divert(&divert_body, &divert_body_cnt,
			&divert_body_len, yypvt[-0].s);
		free(yypvt[-0].s);
		} break;
case 4:
{
		if(bug)printf("%s$%s$\n----------\n", 
			"start 2: start tstat=\n",
			yypvt[-0].s);
		foo = divert(&divert_body, &divert_body_cnt,
			&divert_body_len, yypvt[-0].s);
		free(yypvt[-0].s);
		} break;
case 5:
{
		if(bug)printf("%s$%s$%s$\n----------\n", 
			"start 2a: start INSTANCE tstat=\n",
			yypvt[-1].s, yypvt[-0].s);
		if (!inplayer)
			yyerror("Instance declaration not in body of Player");
		if (first_inst == 0) {
			char *x = scpy(3, "struct ", vs[playercnt].player,
				" {\n");
			foo = divert(&divert_instance_decl, 
				&divert_instance_decl_cnt,
				&divert_instance_decl_len, x);
			first_inst = 1;
			vs[playercnt].has_instance_data = 1;
			free(x);
		}
		foo = divert(&divert_instance_decl, &divert_instance_decl_cnt,
			&divert_instance_decl_len, yypvt[-0].s);
		parse_decl(yypvt[-0].s);
		free(yypvt[-1].s);
		free(yypvt[-0].s);
		} break;
case 6:
{
		if(bug)printf("%s$%s$\n----------\n",
			"start 3: start LRCRLY=\n", 
			yypvt[-0].s);
		if (--crlycnt == 0 && inplayer) {
			if (first_inst != 0) {
				char *x = "\n};\n";
				foo = divert(&divert_instance_decl, 
					&divert_instance_decl_cnt,
					&divert_instance_decl_len, x);
			}
			foo = undivert(&divert_instance_decl,
				&divert_instance_decl_cnt,
				&divert_instance_decl_len);
			foo = undivert(&divert_body, 
				&divert_body_cnt,
				&divert_body_len);
			printf("%s%s%s%s", 
				white, 
				"\treturn(*_x);\n",
				white, 
				yypvt[-0].s); 
			inplayer = 0;
			first_inst = 0;
			clear_hash();
		} else {
			char *x = scpy(3, white, yypvt[-0].s, "\n");
			foo = divert(&divert_body, &divert_body_cnt,
				&divert_body_len, x);
			free(x);
		}
		if (crlycnt < 0)
		    yyerror("Playery: more right than left curly braces seen");
		free(yypvt[-0].s);
		} break;
case 7:
{
		if(bug)printf("%s$%s$%s$%s$%s$%s$\n----------\n",
			"start 4: start player LSYMBOL LLPAREN args LRPAREN=\n",
			yypvt[-4].s, yypvt[-3].s, yypvt[-2].s, yypvt[-1].s, yypvt[-0].s);
		foo = undivert(&divert_body, &divert_body_cnt,
			&divert_body_len);
		{
			char *x = scpy(7, yypvt[-4].s, "Player\n",
				yypvt[-3].s, yypvt[-2].s, "_x", yypvt[-0].s, "\n\tPlayer *_x;");
			foo = divert(&divert_body, &divert_body_cnt,
				&divert_body_len, x);
			free(x);
		}
		vs[playercnt].player = yypvt[-3].s;
		if (yypvt[-1].s != 0) {			
			char *x, *y, *z, *index();	
			int	flag = 1;

			
			if ((x = index(yypvt[-1].s, ',')) != 0) {
				flag++;	
				*x = '\0';
				if ((y = index(x+1, ',')) != 0) {
					flag++;	
					*y = '\0';
					if ((z = index(y+1, ',')) != 0) {
						flag++;	
						*z = '\0';
					}
				}
			}

			switch (flag) {
			case 1:
				vs[playercnt].begin = scpy(1, yypvt[-1].s);
				if (integer)
				    vs[playercnt].dur = scpy(1, "-1L");
				else
				    vs[playercnt].dur = scpy(1, "-1.0");
				vs[playercnt].stat = scpy(1, "P_READY");
				vs[playercnt].cnt = scpy(1, "1");
				break;
			case 2:
				vs[playercnt].begin = scpy(1, yypvt[-1].s);
				vs[playercnt].dur = scpy(1, x+1);
				vs[playercnt].stat = scpy(1, "P_READY");
				vs[playercnt].cnt = scpy(1, "1");
				break;
			case 3:
				vs[playercnt].begin = scpy(1, yypvt[-1].s);
				vs[playercnt].dur = scpy(1, x+1);
				vs[playercnt].stat = scpy(1, y+1);
				vs[playercnt].cnt = scpy(1, "1");
				break;
			case 4:
				vs[playercnt].begin = scpy(1, yypvt[-1].s);
				vs[playercnt].dur = scpy(1, x+1);
				vs[playercnt].stat = scpy(1, y+1);
				vs[playercnt].cnt = scpy(1, z+1);
				break;
			}
			vs[playercnt].rstat = 1;
		} else {			
			vs[playercnt].rstat = 0;
		}
		countparens = 0;
		inplayer = 1;
		free(yypvt[-4].s); free(yypvt[-2].s); 
		if (yypvt[-1].s != 0) 
			free(yypvt[-1].s); 
		free(yypvt[-0].s);
		} break;
case 8:
{
		yyval.s = scpy(1, white);
		free(yypvt[-0].s);
		countparens = 1;
		parencnt = 0;
		playercnt++;
		} break;
case 9:
{ 
		if(bug)printf("arg 0: <NULL>\n----------\n");
		yyval.s = 0; 
		} break;
case 10:
{
		if(bug)printf("%s$%s$\n----------\n",
			"arg 1: arg_obj=\n",
			yypvt[-0].s);
		yyval.s = scpy(1, yypvt[-0].s);
		free(yypvt[-0].s); 
		} break;
case 11:
{
		if(bug)printf("%s$%s$%s$\n----------\n",
			"arg3: args arg_obj=\n",
			yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(2, yypvt[-1].s, yypvt[-0].s);
		free(yypvt[-0].s);
		} break;
case 12:
{
		if(bug)printf("%s$%s$%s$%s$\n----------\n",
			"arg4: args LCOMMA arg_obj=\n",
			yypvt[-2].s, yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(3, yypvt[-2].s, yypvt[-1].s, yypvt[-0].s);
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 13:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 14:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 15:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 16:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 17:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 18:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 19:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 20:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 21:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 22:
{ yyval.s = scpy(2, white, yypvt[-0].s); free(yypvt[-0].s); } break;
case 23:
{
		if(bug)printf("%s$%s$\n----------\n",
			"stat 0: obj=\n",
			yypvt[-0].s);
		yyval.s = scpy(1, yypvt[-0].s);
		free(yypvt[-0].s); 
		} break;
case 24:
{
		if(bug)printf("%s$%s$%s$\n----------\n",
			"stat 1: stat obj=\n",
			yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(2, yypvt[-1].s, yypvt[-0].s);
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 25:
{
		if(bug)printf("%s$%s$%s$\n----------\n",
			"stat2: stat cycl=\n",
			yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(2, yypvt[-1].s, yypvt[-0].s);
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 26:
{
		if(bug)printf("%s$%s$%s$\n----------\n",
			"stat 3: stat gen=\n",
			yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(2, yypvt[-1].s, yypvt[-0].s);
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 27:
{
		if(bug)printf("%s$%s$\n----------\n",
			"stat 4: motive=\n",
			yypvt[-0].s);
		yyval.s = scpy(1, yypvt[-0].s);
		free(yypvt[-0].s);
		} break;
case 28:
{
		if(bug)printf("%s$%s$%s$\n----------\n",
			"stat 5: stat PLAYER=\n",
			yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(3, yypvt[-1].s, white, yypvt[-0].s);
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 29:
{
		if(bug)printf("%s$%s$%s$\n----------\n",
			"tstat: stat LSEMI=\n",
			yypvt[-1].s, yypvt[-0].s);
		yyval.s = scpy(2, yypvt[-1].s, yypvt[-0].s);
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 30:
{
		if (!inplayer)
			yyerror("Playery: cyclic list not in body of Player");
		yyval.s = scpy(2, white, yypvt[-0].s);
		free(yypvt[-0].s);
		parencnt = 0;
		countparens = 1;
		} break;
case 31:
{
		if(bug)printf("%s$%s$%s$%s$%s$\n----------\n",
			"cycl: cyclh LLPAREN stat LRPAREN=\n",
			yypvt[-3].s, yypvt[-2].s, yypvt[-1].s, yypvt[-0].s);
		nl2sp(yypvt[-1].s);
		yyval.s = scpy(6, yypvt[-3].s, yypvt[-2].s, "\"", yypvt[-1].s, "\"", yypvt[-0].s);
		free(yypvt[-3].s); free(yypvt[-2].s); free(yypvt[-1].s); free(yypvt[-0].s);
		countparens = 0;
		} break;
case 32:
{
		yyval.s = scpy(2, white, yypvt[-0].s);
		free(yypvt[-0].s);
		parencnt = 0;
		countparens = 1;
		} break;
case 33:
{
		if(bug)printf("%s$%s$%s$%s$%s$\n----------\n",
			"cycl: genh LLPAREN stat LRPAREN=\n",
			yypvt[-3].s, yypvt[-2].s, yypvt[-1].s, yypvt[-0].s);
		nl2sp(yypvt[-1].s);
		yyval.s = scpy(6, yypvt[-3].s, yypvt[-2].s, "\"", yypvt[-1].s, "\"", yypvt[-0].s);
		free(yypvt[-3].s); free(yypvt[-2].s); free(yypvt[-1].s); free(yypvt[-0].s);
		countparens = 0;
		} break;
case 34:
{
		if (!inplayer)
			yyerror("Playery: Motive not in body of Player");
		yyval.s = scpy(2, white, yypvt[-0].s);
		free(yypvt[-0].s);
		parencnt = 0;
		countparens = 1;
		} break;
case 35:
{
		if(bug)printf("%s$%s$%s$%s$%s$\n----------\n",
			"motive: motivh LLPAREN stat LRPAREN=\n",
			yypvt[-3].s, yypvt[-2].s, yypvt[-1].s, yypvt[-0].s);
		nl2sp(yypvt[-1].s);
		yyval.s = scpy(6, yypvt[-3].s, yypvt[-2].s, "\"", yypvt[-1].s, "\"", yypvt[-0].s);
		free(yypvt[-3].s); free(yypvt[-2].s); free(yypvt[-1].s); free(yypvt[-0].s);
		countparens = 0;
		} break;
case 36:
{ 
		char *c;
		if (!inplayer)
			yyerror("Playery: P field not in body of Player");
		c = getpnum(yypvt[-0].s);
		yyval.s = scpy(4, white, "_x->P_pn[", c, "]");
		vs[playercnt].hi_ref_pn = max(vs[playercnt].hi_ref_pn, atoi(c));
		free(yypvt[-0].s);
		} break;
case 37:
{ 
		char *c;
		if (!inplayer)
			yyerror("Playery: P field not in body of Player");
		c = getpnum(yypvt[-0].s);
		yyval.s = scpy(4, white, "_x->P_ps[", c, "]");
		vs[playercnt].hi_ref_pn = max(vs[playercnt].hi_ref_pn, atoi(c));
		free(yypvt[-0].s);
		} break;
case 38:
{ 
		char *c;
		if (!inplayer)
			yyerror("Playery: P field not in body of Player");
		c = getpnum(yypvt[-0].s);
		yyval.s = scpy(4, white, "_x->P_pi[", c, "]");
		vs[playercnt].hi_ref_pn = max(vs[playercnt].hi_ref_pn, atoi(c));
		free(yypvt[-0].s);
		} break;
case 39:
{ 
		char *c;
		if (!inplayer)
			yyerror("Playery: P field not in body of Player");
		c = getpnum(yypvt[-0].s);
		yyval.s = scpy(4, white, "_x->P_pp[", c, "]");
		vs[playercnt].hi_ref_pn = max(vs[playercnt].hi_ref_pn, atoi(c));
		free(yypvt[-0].s);
		} break;
case 40:
{ 
		if (!inplayer)
			yyerror("Playery: Start block not in body of Player");
		yyval.s = scpy(3, white, "if(_x->P_icode==0)", yypvt[-0].s);
		crlycnt++;
		free(yypvt[-1].s); free(yypvt[-0].s);
		} break;
case 41:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s);
		m_start_seen++;
		free(yypvt[-0].s); 
		} break;
case 42:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s);
		t_start_seen++;
		free(yypvt[-0].s); 
		} break;
case 43:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 44:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 45:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 46:
{ 
		if (lookup(yypvt[-0].s)) {
			if(bug)printf("%s$%s$", "Instance symbol: ", yypvt[-0].s);
			yyval.s = scpy(5, white, "((struct ", vs[playercnt].player,
				" *)_x->P_nstnc)->", yypvt[-0].s);
		} else {
			if(bug)printf("%s$%s$\n", "lsymbol:", yypvt[-0].s);
			yyval.s = scpy(2, white, yypvt[-0].s); 
		}
		if (bug)printf("----------\n");
		free(yypvt[-0].s);
		} break;
case 47:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 48:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 49:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 50:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 51:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 52:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 53:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 54:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 55:
{ 
		yyerror("Playery: error in lexer");
		exit(1);
		} break;
case 56:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 57:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 58:
{ 
		crlycnt++;
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 59:
{ 
		crlycnt--;
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 60:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 61:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 62:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
case 63:
{ 
		yyval.s = scpy(2, white, yypvt[-0].s); 
		free(yypvt[-0].s);
		} break;
	}
	goto yystack;		
}
