# define LOWPREC 257
# define UNARY 258
# define TWOOP 259
# define ONEOP 260
# define NOOP 261
# define ONECOM 262
# define CSTRING 263
# define UINT 264
# define LTO 265
# define IFCOM 266
# define LEDIT 267
# define LIFTF 268
# define LTRACE 269
# define LPROC 270
# define LPEND 271
# define LAEND 272
# define LGO 273
# define CLIST 274
# define TWOCOM 275
# define NOCOM 276
# define RUNCOM 277
# define RNEND 278
# define REPCOM 279
# define THREECOM 280

# line 13 "logo.y"
 
#include "logo.h"

char popname[NAMELEN+1];
int multnum;
struct object *multarg = 0;
#include <setjmp.h>
extern jmp_buf runret;
jmp_buf yerrbuf;
int catching = 0;
int flagquit = 0;
extern struct runblock *thisrun;
#ifndef NOTURTLE
extern int turtdes;
extern struct display *mydpy;
#endif
int errtold = 0;
int yyline =0;
char ibuf[IBUFSIZ] ={0};
char *ibufptr =NULL;
char *getbpt =0;
char titlebuf[100] ={0};
char *titleptr =NULL;
extern char *cpystr();
int letflag =0;
int topf =0;
int pflag =0;
char charib =0;
int endflag =0, rendflag = 0;
int traceflag =0;
int currtest = 0;
int argno =(-1);
int *stkbase =NULL;
int stkbi =0;
struct stkframe *fbr =NULL;
struct plist *proclist =NULL;
#ifdef PAUSE
int pauselev = 0;
extern int psigflag,errpause;
#endif

struct object *add(), *sub(), *mult(), *div(), *rem(), *and(), *or();
struct object *greatp(), *lessp(), *lmax(), *lmin(), *lis();
struct object *worcat(), *sencat(), *equal(), *lemp(), *comp();
struct object *lnump(), *lsentp(), *lwordp(), *length(), *zerop();
struct object *first(), *butfir(), *last(), *butlas(), *alllk();
struct object *lnamep(), *lrandd(), *rnd(), *sq(), *lpow(), *lsin();
struct object *lcos(), *latan(), *ltime(), *request(), *readlist();
struct object *cmprint(), *cmtype(), *cmoutput(), *lsleep(), *lbreak();
struct object *cmlocal(), *assign(), *cmedit(), *lstop(), *show(), *erase();
struct object *help(), *describe(), *ltrace(), *luntrace(), *lbyecom();
struct object *sometrace();
#ifndef NOTURTLE
struct object *getturtle(), *forward(), *back();
struct object *left(), *right(), *penup(), *cmpendown(), *clearscreen();
struct object *fullscreen(), *splitscreen(), *showturtle();
struct object *hideturtle(), *textscreen(), *cmpenerase(), *pencolor();
struct object *wipeclean(), *penmode(), *penreverse(), *shownp(), *towardsxy();
struct object *setcolor(), *setxy(), *setheading();
struct object *xcor(), *ycor(), *heading(), *getpen();
struct object *scrunch(), *setscrunch();
#endif
struct object *ltopl(), *cmfprint(), *cmftype(), *pots(), *fput(), *lput();
struct object *list(), *loread(), *lowrite(), *fileclose(), *cbreak();
struct object *lfread(), *lfword(), *fileprint(), *filefprint();
struct object *filetype(), *fileftype(), *callunix(), *repcount();
#ifdef DEBUG
struct object *setdebquit(), *setmemtrace(), *setyaccdebug();
#endif
struct object *readchar(), *keyp(), *intpart(), *round(), *toascii();
struct object *tochar(), *loflush(), *settest(), *memberp(), *item();
#ifdef PAUSE
struct object *unpause(), *dopause(), *setipause(), *setqpause(); /* PAUSE */
struct object *seterrpause(), *clrerrpause();
#endif
#ifdef FLOOR
struct object *hitoot(), *lotoot(), *lampon(), *lampoff();
struct object *ftouch(), *btouch(), *ltouch(), *rtouch();
#endif
#ifndef SMALL
struct object *gprop(), *plist(), *pps(), *remprop();
#endif
#ifdef SETCURSOR
struct object *clrtxt(), *setcur();
#endif

struct lexstruct keywords[] =
{
	"sum",TWOOP,add,NULL,
	"difference",TWOOP,sub,"diff",
	"product",TWOOP,mult,NULL,
	"quotient",TWOOP,div,NULL,
	"remainder",TWOOP,rem,"mod",
	"both",TWOOP,and,"and",
	"either",TWOOP,or,"or",
	"greaterp",TWOOP,greatp,NULL,
	"lessp",TWOOP,lessp,NULL,
	"maximum",TWOOP,lmax,"max",
	"minimum",TWOOP,lmin,"min",
	"is",TWOOP,lis,NULL,
	"word",TWOOP,worcat,NULL,
	"sentence",TWOOP,sencat,"se",
	"equalp",TWOOP,equal,NULL,
	"emptyp",ONEOP,lemp,NULL,
	"not",ONEOP,comp,NULL,
	"numberp",ONEOP,lnump,NULL,
	"sentencep",ONEOP,lsentp,NULL,
	"wordp",ONEOP,lwordp,NULL,
	"count",ONEOP,length,NULL,
	"zerop",ONEOP,zerop,NULL,
	"first",ONEOP,first,NULL,
	"butfirst",ONEOP,butfir,"bf",
	"last",ONEOP,last,NULL,
	"butlast",ONEOP,butlas,"bl",
	"thing",ONEOP,alllk,NULL,
	"namep",ONEOP,lnamep,NULL,
	"random",ONEOP,rnd,"rnd",
	"sqrt",ONEOP,sq,NULL,
	"pow",TWOOP,lpow,NULL,
	"sin",ONEOP,lsin,NULL,
	"cos",ONEOP,lcos,NULL,
	"arctan",ONEOP,latan,"atan",
	"time",NOOP,ltime,NULL,
#ifndef NEXT
	"request",NOOP,request,NULL,
	"readlist",NOOP,readlist,"rl",
#endif NEXT
	"print",ONECOM,cmprint,"pr",
	"type",ONECOM,cmtype,NULL,
	"output",ONECOM,cmoutput,"op",
	"wait",ONECOM,lsleep,NULL,
	"local",ONECOM,cmlocal,NULL,
	"make",TWOCOM,assign,NULL,
	"if",IFCOM,0,NULL,
	"to",LTO,0,NULL,
	"end",LPEND,0,NULL,
	"stop",NOCOM,lstop,NULL,
	"break",NOCOM,lbreak,NULL,
#ifndef NEXT
	"edit",LEDIT,cmedit,"ed",
#endif NEXT
	"go",LGO,0,NULL,
	"show",ONECOM,show,"po",
	"erase",ONECOM,erase,"er",
	"help",NOCOM,help,NULL,
	"describe",ONECOM,describe,NULL,
	"trace",LTRACE,sometrace,NULL,
	"untrace",NOCOM,luntrace,NULL,
	"goodbye",NOCOM,lbyecom,"bye",
#ifndef NOTURTLE
	"turtle",ONECOM,getturtle,"tur",
	"forward",ONECOM,forward,"fd",
	"back",ONECOM,back,"bk",
	"left",ONECOM,left,"lt",
	"right",ONECOM,right,"rt",
#ifdef FLOOR
	"hitoot",ONECOM,hitoot,"hit",
	"lotoot",ONECOM,lotoot,"lot",
	"lampon",NOCOM,lampon,"lon",
	"lampoff",NOCOM,lampoff,"loff",
#endif
	"penup",NOCOM,penup,"pu",
	"pendown",NOCOM,cmpendown,"pd",
	"clearscreen",NOCOM,clearscreen,"cs",
#ifndef NEXT
	"fullscreen",NOCOM,fullscreen,"full",
	"splitscreen",NOCOM,splitscreen,"split",
#endif  /* NEXT */
	"showturtle",NOCOM,showturtle,"st",
	"hideturtle",NOCOM,hideturtle,"ht",
#ifndef NEXT
	"textscreen",NOCOM,textscreen,"text",
#endif  /* NEXT */
	"penerase",NOCOM,cmpenerase,"pe",
	"pencolor",ONECOM,pencolor,"penc",
	"setcolor",TWOCOM,setcolor,"setc",
	"setxy",TWOCOM,setxy,NULL,
	"setheading",ONECOM,setheading,"seth",
	"wipeclean",NOCOM,wipeclean,"clean",
	"penmode",NOOP,penmode,NULL,
	"penreverse",NOCOM,penreverse,"px",
	"shownp",NOOP,shownp,NULL,
	"towardsxy",TWOOP,towardsxy,NULL,
#ifdef FLOOR
	"ftouch",NOOP,ftouch,"fto",
	"btouch",NOOP,btouch,"bto",
	"ltouch",NOOP,ltouch,"lto",
	"rtouch",NOOP,rtouch,"rto",
#endif
	"xcor",NOOP,xcor,NULL,
	"ycor",NOOP,ycor,NULL,
	"heading",NOOP,heading,NULL,
	"getpen",NOOP,getpen,NULL,
	"scrunch",NOOP,scrunch,NULL,
	"setscrunch",ONECOM,setscrunch,"setscrun",
#endif
	"toplevel",NOCOM,ltopl,NULL,
	"fprint",ONECOM,cmfprint,"fp",
	"ftype",ONECOM,cmftype,"fty",
	"pots",NOCOM,pots,NULL,
	"fput",TWOOP,fput,NULL,
	"lput",TWOOP,lput,NULL,
	"list",TWOOP,list,NULL,
	"openread",ONEOP,loread,"openr",
	"openwrite",ONEOP,lowrite,"openw",
	"close",ONECOM,fileclose,NULL,
	"fileread",ONEOP,lfread,"fird",
	"fileword",ONEOP,lfword,"fiwd",
	"fileprint",TWOCOM,fileprint,"fip",
	"filefprint",TWOCOM,filefprint,"fifp",
	"filetype",TWOCOM,filetype,"fity",
	"fileftype",TWOCOM,fileftype,"fifty",
	"unix",ONECOM,callunix,NULL,
	"run",RUNCOM,0,NULL,
	"repeat",REPCOM,0,NULL,
	"repcount",NOOP,repcount,NULL,
#ifdef DEBUG
	"debquit",NOCOM,setdebquit,NULL,
	"memtrace",NOCOM,setmemtrace,NULL,
	"yaccdebug",NOCOM,setyaccdebug,NULL,
#endif
	"cbreak",ONECOM,cbreak,NULL,
#ifndef NEXT
	"readchar",NOOP,readchar,"rc",
#endif  NEXT
	"keyp",NOOP,keyp,NULL,
	"int",ONEOP,intpart,NULL,
	"round",ONEOP,round,NULL,
	"ascii",ONEOP,toascii,NULL,
	"char",ONEOP,tochar,NULL,
	"oflush",NOCOM,loflush,NULL,
#ifndef SMALL
	"gprop",TWOOP,gprop,NULL,
	"plist",ONEOP,plist,NULL,
	"pprop",THREECOM,0,NULL,
	"pps",NOCOM,pps,NULL,
	"remprop",TWOCOM,remprop,NULL,
#endif
	"test",ONECOM,settest,NULL,
	"iftrue",LIFTF,(struct object *(*)())1,"ift",
	"iffalse",LIFTF,0,"iff",
	"memberp",TWOOP,memberp,NULL,
	"item",TWOOP,item,"nth",
#ifdef PAUSE
	"continue",NOCOM,unpause,"co",
	"pause",NOCOM,dopause,NULL,
	"setipause",NOCOM,setipause,NULL,
	"setqpause",NOCOM,setqpause,NULL,
	"errpause",NOCOM,seterrpause,NULL,
	"errquit",NOCOM,clrerrpause,NULL,
#endif
#ifdef SETCURSOR
	"cleartext",NOCOM,clrtxt,"ct",
	"setcursorxy",TWOCOM,setcur,"setcxy",
#endif
	NULL,NULL,NULL,NULL,
};

#define uperror {errtold++;YYERROR;}

#ifdef PAUSE
#define catch(X) {if(!setjmp(yerrbuf)){if(flagquit)errhand();catching++;X;catching=0;}else{catching=0;uperror}}
#else
#define catch(X) {X;}
#endif
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern short yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256

# line 673 "logo.y"


extern struct object *makelist();

#ifdef PAUSE
yylex1()
#else
yylex()
#endif
{
	register char *str;
	char s[100];
	char c;
	register pc;
	register i;
	NUMBER dubl;
	int floatflag;
	FIXNUM fixn;

	if (yyerrflag) return(1);
	else if (argno==0 && pflag!=1) {
		if (fbr->oldyyc==-2) fbr->oldyyc= -1;
		return(LAEND);
	} else if (endflag==1 && pflag>1) {
		endflag=0;
		return(LPEND);
	}
	else if (pflag==2) {
		pc= *(stkbase+stkbi++);
		if (stkbi==PSTKSIZ-1) {
			stkbase= (int *)(*(stkbase+PSTKSIZ-1));
			stkbi=1;
		}
		yylval= *(stkbase+stkbi++);
		if (pc==LPROC || pc==CSTRING || pc==UINT || pc==CLIST) {
		    yylval=(int)localize((struct object *)yylval);
		}
		if (stkbi==PSTKSIZ-1) {
			stkbase= (int *)(*(stkbase+PSTKSIZ-1));
			stkbi=1;
		}
		if (pc== -1) return(0);
		else return(pc);
	} else if (letflag==1) {
		str=s;
		while (!index(" \t\n[](){}\";",(c = getchar()))) {
			if (c == '\\') c = getchar() /* |0200 */ ;
			else if (c == '%') c = ' ' /* |0200 */ ;
			*str++ = c;
		}
		charib=c;
		*str='\0';
		yylval=(int)localize(objcpstr(s));
		letflag=0;
		return(CSTRING);
	} else if (letflag==2) {
		str = s;
		while (( (c=getchar())>='a' && c<='z' )
				|| (c>='A' && c<='Z') || (c>='0' && c<='9')
				|| (c=='.') || (c=='_') ) {
			if (c>='A' && c<='Z') c += 040;
			*str++ = c;
		}
		charib = c;
		*str = '\0';
		letflag = 0;
		yylval = (int)localize(objcpstr(s));
		return(CSTRING);
	}
	else if (letflag==3) {
		yylval = (int)makelist();
		letflag = 4;
		return(CLIST);
	}
	else if (letflag==4) {
		letflag = 0;
		return(yylval = getchar());
	}
	while ((c=getchar())==' ' || c=='\t')
		;
	if (rendflag) {
		getbpt = 0;
		if (rendflag < 3)
			--rendflag;
		else if (!thisrun || thisrun->svpflag)
			rendflag = 0;
		return(RNEND);
	}

	if (c == '!')	/* comment feature */
		while ((c=getchar()) && (c != '\n')) ;

	if ((c<'a' || c>'z') && (c<'A' || c>'Z')
			&& (c<'0' || c>'9') && c!='.') {
		yylval=c;
		if (c=='\"') letflag=1;
		if (c==':') letflag=2;
		if (c=='[') letflag=3;
		return(c);
	}
	else if ((c>='0' && c<='9')|| c=='.') {
		floatflag = (c=='.');
		str=s;
		while ((c>='0' && c<='9')||(c=='E')||(c=='e')||(c=='.')) {
			*str++=c;
			if (c=='.') floatflag++;
			if ((c=='e')||(c=='E')) {
				floatflag++;
				c = getchar();
				if ((c=='+')||(c=='-')) {
					*str++ = c;
					c = getchar();
				}
			} else c=getchar();
		}
		charib=c;
		*str='\0';
		if (floatflag) {
			sscanf(s,EFMT,&dubl);
			yylval=(int)localize(objdub(dubl));
		} else {
			sscanf(s,FIXFMT,&fixn);
			yylval=(int)localize(objint(fixn));
		}
		return(UINT);
	} else {
		if (c < 'a') c += 040;
		yylval=(int)(str=s);
		*str++=c;
		c=getchar();
		if (c >= 'A' && c <= 'Z') c += 040;
		while ((c>='a' && c<='z') || (c>='0' && c<='9')
				|| (c=='.') || (c=='_')) {
			*str++=c;
			c=getchar();
			if (c >= 'A' && c <= 'Z') c += 040;
		}
		charib=c;
		*str='\0';
		for (i=0;keywords[i].word; i++) {
			if (!strcmp(yylval,keywords[i].word) ||
 			    (keywords[i].abbr && 
 			     !strcmp(yylval,keywords[i].abbr))) {
				yylval=i;
				return(keywords[i].lexret);
			}
		}
		yylval=(int)localize(objcpstr(s));
		return(LPROC);
	}
}

#ifdef PAUSE
yylex() {
	int x;

	if (catching) return(yylex1());
	if (!setjmp(yerrbuf)) {
		if (flagquit) errhand();
		catching++;
		x = yylex1();
		catching=0;
		return(x);
	} else {
		catching=0;
		return(12345);	/* This should cause an error up there */
	}
}
#endif

int isuint(x)
int x;
{
	return(x == UINT);
}

int isstored(x)
int x;
{
	return(x==UINT || x==LPROC || x==CSTRING || x==CLIST);
}

yyprompt(clear) {
	register int i;

	if (!ibufptr && !getbpt && !pflag) {
		flagquit = 0;
#ifdef PAUSE
		if (pauselev > 0) {
			for (i=pauselev; --i >=0; )
				putchar('-');
		}
#endif
#ifndef NEXT
		putchar('?');
#endif  NEXT
#ifndef NOTURTLE
		if ((turtdes<0) && clear)
			(*mydpy->state)('*');
#endif
		fflush(stdout);
	}
}

short yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
-1, 20,
	60, 22,
	62, 22,
	61, 22,
	43, 22,
	45, 22,
	42, 22,
	47, 22,
	92, 22,
	94, 22,
	-2, 25,
-1, 21,
	60, 23,
	62, 23,
	61, 23,
	43, 23,
	45, 23,
	42, 23,
	47, 23,
	92, 23,
	94, 23,
	-2, 26,
-1, 157,
	60, 0,
	62, 0,
	61, 0,
	-2, 53,
-1, 159,
	60, 0,
	62, 0,
	61, 0,
	-2, 55,
-1, 161,
	60, 0,
	62, 0,
	61, 0,
	-2, 57,
-1, 179,
	0, 43,
	42, 43,
	47, 43,
	92, 43,
	94, 43,
	262, 43,
	265, 43,
	267, 43,
	268, 43,
	269, 43,
	271, 43,
	272, 43,
	273, 43,
	275, 43,
	276, 43,
	278, 43,
	280, 43,
	-2, 41,
-1, 180,
	0, 44,
	262, 44,
	265, 44,
	267, 44,
	268, 44,
	269, 44,
	271, 44,
	272, 44,
	273, 44,
	275, 44,
	276, 44,
	278, 44,
	280, 44,
	-2, 42,
-1, 196,
	256, 35,
	60, 35,
	62, 35,
	61, 35,
	43, 35,
	42, 35,
	47, 35,
	92, 35,
	94, 35,
	-2, 24,
	};
# define YYNPROD 132
# define YYLAST 1330
short yyact[]={

  16,  98, 171,  63, 137,  99,  97, 133, 111,   9,
 167, 169,  64, 131,  48,  49,  68, 102,  53, 129,
  21,   2,  16, 144,  31,  18,  60,  45, 186,  71,
  37,  52,  44,  20,  60,  35, 103, 100,  16, 101,
  43, 104,  41,  40,  16,  39,  31, 116,  33,  17,
 191, 189,  37, 170, 114,  72,  38,  35, 103, 100,
  77, 101,  67, 104,  72,  19,  16, 103,  31, 142,
  33,  17, 104,  26,  37,  61, 107, 106, 108,  35,
  25,  32, 192,  61,  14,  21, 105,  17, 102,  13,
  31,  12,  33,  17,  16, 168,  37, 136,  20,  62,
   6,  35,   1,  32,   0,   0, 143,   0, 105,  66,
 102,   0,   0,  36,  33,  17,   0, 105,  31, 102,
   0, 134,   0,   0,  37,  32, 103, 100,   0, 126,
  69, 104, 173, 174, 175,  36,   0,  21,  21,  21,
 163, 166,  33,  17, 107, 106, 108,  32, 184,   0,
  20,  20,  20, 118, 119, 120,  31,  36,   0,   0,
   0,   0,  37,   0, 103, 100,   0, 126,   0, 104,
   0,   0,   0,   0, 185,  32, 105, 188, 102,  36,
  33,   0, 107, 106, 108,  80,  79,  78,  82,   0,
   0,  86,  85,  87,  88,   0,  76,  92,   0,  89,
   0,  83,  81,  90,   0,  91,  84,  36,  21, 193,
   0,  21, 197,  32, 105,   0, 102,   0,   0,   0,
   0,  20,   0,   0,  20,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,  36, 194,   0,   0,  27,
  28,  29,  15, 135, 196,  24,  22,   4,  23,   5,
  42, 195,  70,  11,   0,   7,  10,  46, 130,  47,
   8,  27,  28,  29,  15,   0,  30,  24,  22,   4,
  23,   5,  42,   0,   0,  11,   0,   7,  10,  46,
 132,  47,   8,  27,  28,  29,  15,   0,  30,  24,
  22,   4,  23,   5,  42, 198,   0,  11,   0,   7,
  10,  46,   3,  47,   8,  27,  28,  29,  15,   0,
  30,  24,  22,   4,  23,   5,  42,   0,   0,  11,
   0,   7,  10,  46,   0,  47,   8,   0,   0,   0,
   0,   0,   0,  27,  28,  29,   0,  31,  30,   0,
  54,   0,   0,  37,  42, 103, 100,   0, 126,   0,
 104,  46,   0,  47,   0,   0,   0,   0,   0,   0,
   0,  33,   0, 107, 106, 108,   0,   0, 141,   0,
   0,  27,  28,  29,  31,   0,  30,   0,  54,   0,
  37,   0,  42,   0,   0,  35,   0,   0,   0,  46,
   0,  47,   0,   0,  32, 105,  31, 102,  33,   0,
   0,   0,  37,   0,   0,   0,   0,  35,  31,   0,
   0,   0,   0,   0,  37,   0,   0,   0,   0,  35,
  33,   0,   0,   0,   0,   0,  36,   0,   0,  59,
  31,  32,  33,   0,   0,   0,  37,   0,   0,   0,
   0,  35,   0,   0,  65,   0,   0,   0,   0,   0,
   0,   0,   0,  32,  33,  31, 169, 103, 100,   0,
 101,  37, 104,  36,   0,  32,  35,  31,   0,   0,
   0,   0,   0,  37,   0, 107, 106, 108,  35,  33,
 123,   0,   0, 103, 100,  36, 101,  32, 104,  31,
   0,  33,   0,   0,   0,  37,   0,  36,   0,   0,
  35, 107, 106, 108,   0, 139,   0, 105,   0, 102,
   0,   0,  32,  33,  31,   0,   0,   0,   0,  36,
  37,   0,   0,   0,  32,  35,  31,   0,   0,   0,
   0,   0,  37, 105,   0, 102,   0,  35,  33,   0,
 168,   0,   0,   0,  36,   0,  32,   0,  31,   0,
  33,   0,   0,   0,  37, 178,  36,   0, 182,  35,
   0,   0,  27,  28,  29,   0,   0,  30,   0,  54,
  31,  32,  33,  42,   0,   0,  37,   0,  36,   0,
  46,  35,  47,  32,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,  33,   0, 180,   0,   0,  27,
  28,  29,   0,  36,  30,  32,  54,   0,   0,   0,
  42, 190,   0,   0,   0,  36,   0,  46,  94,  47,
   0,  27,  28,  29,   0,   0,  30,  32,  54,   0,
 162,   0,  42,  27,  28,  29,   0,  36,  30,  46,
  54,  47,   0,   0,  42,   0,   0,   0,   0,   0,
   0,  46, 160,  47,   0,  27,  28,  29,   0,  36,
  30,   0,  54,   0,   0,   0,  42,   0,   0,   0,
   0,   0,  31,  46,   0,  47,   0, 158,  37,   0,
  27,  28,  29,  35,   0,  30,   0,  54,   0, 156,
   0,  42,  27,  28,  29,   0,  33,  30,  46,  54,
  47,   0,   0,  42,   0,   0,   0,   0,   0,   0,
  46, 154,  47,   0,  27,  28,  29,   0,   0,  30,
   0,  54,   0,   0,   0,  42,   0,   0,   0,  32,
   0,  31,  46,   0,  47,   0, 152,  37,   0,  27,
  28,  29,  35,   0,  30,   0,  54,   0, 150,   0,
  42,  27,  28,  29,   0,  33,  30,  46,  54,  47,
   0,  36,  42,   0,   0,   0,  31,   0,   0,  46,
 148,  47,  37,  27,  28,  29,   0,  35,  30,   0,
  54,   0,   0,   0,  42,   0,   0,   0,  32,   0,
  33,  46, 146,  47,   0,  27,  28,  29,   0,   0,
  30,  31,  54,   0,   0,   0,  42,  37,   0,   0,
   0,   0,  35,  46,   0,  47,   0,   0,   0,   0,
  36,   0,   0,  32,   0,  33,   0,  31,   0,   0,
   0,   0,   0,  37,   0,   0,   0,   0,  35,  31,
   0,   0,   0,   0,   0,  37,   0,   0,   0,   0,
  35,  33,   0,   0,   0,  36,   0,   0,  32,   0,
   0,  31,   0,  33,   0,   0,   0,  37,   0,   0,
   0,   0,  35,   0,   0,   0,   0,   0,   0,   0,
   0,   0,  31,   0,  32,  33,   0,   0,  37,   0,
  36,   0,   0,  35,  74,   0,  32,  27,  28,  29,
   0,   0,  30,   0,  54,   0,  33,   0,  42,   0,
   0,   0,   0,   0,   0,  46,  36,  47,  32,   0,
   0,  31,   0,   0,   0,   0,   0,  37,  36,   0,
   0,   0,  35,   0,   0,   0,   0,   0,   0,  32,
   0,   0,   0,   0,   0,  33,   0,   0,   0,   0,
  36,   0,   0, 115,   0,   0,  27,  28,  29,   0,
   0,  30,   0,  54,   0,   0,   0,  42,   0,   0,
   0,  36,   0,   0,  46,   0,  47,   0,  32,   0,
   0,   0,   0,   0,   0,   0,   0,   0, 110,   0,
   0,  27,  28,  29,   0,   0,  30,   0,  54,   0,
   0,   0,  42,   0,   0,   0,   0,   0,   0,  46,
  36,  47,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,  96,   0,   0,  27,  28,  29,   0,
   0,  30,   0,  54,   0,   0,   0,  42,   0,   0,
   0,   0,   0,   0,  46,   0,  47,   0,   0,  58,
   0,   0,  27,  28,  29,   0,   0,  30,   0,  54,
   0,  56,   0,  42,  27,  28,  29,   0,   0,  30,
  46,  54,  47,   0,   0,  42,   0,   0,   0,   0,
   0,   0,  46,  51,  47,   0,  27,  28,  29,   0,
   0,  30,   0,  54,   0,   0,   0,  42,   0,   0,
   0,   0,   0,   0,  46,   0,  47,  27,  28,  29,
   0,   0,  30,   0,  54,   0,   0,   0,  42,   0,
   0,   0,   0,   0,   0,  46,   0,  47,   0,   0,
   0,  34,   0,   0,   0,   0,   0,   0,  50,  55,
  57,   0,   0,   0,   0,   0, 112,  28,  29,   0,
   0,  30,   0,  54,  73,  75,   0,  42,   0,  93,
  95,   0,   0,   0,  46,   0,  47, 109,   0, 113,
 117,   0,   0,   0,   0,   0,   0,   0, 121, 122,
   0,   0,   0,   0,   0,   0, 124, 125,   0, 127,
   0,   0,   0,   0, 128,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0, 138,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0, 140,   0,   0,   0,   0,
   0,   0, 145, 147, 149, 151, 153, 155, 157, 159,
 161,   0,   0, 164, 165,   0,   0,   0, 172,   0,
   0,   0,   0,   0, 176,   0, 177,   0, 179, 181,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 183,   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, 164, 187,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0, 183,
   0,   0,   0,   0,   0,   0,   0,   0,   0, 164 };
short yypact[]={

-1000,  56,-1000,-1000,  28,  28, 837, 815, 803,-1000,
  24,-253,-1000,-1000,  24,-1000,-1000,-1000,-1000,   6,
-1000,-1000, 648, 858, -74,-1000,-1000, 372, 777,-1000,
-1000,-257,-273,-258, 451, 742,-251, 897, 707,-1000,
-1000,-1000,-1000,-1000,-1000,-1000, 858, 858,-1000,-1000,
  16,-1000,-1000,-1000, 648, 313,-1000, 313,-1000,-1000,
-1000,-1000, 858,-1000,-1000,-1000,  12,  -3,-1000,-1000,
-1000,-1000,-259, 313,-1000,  16,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000, 122,-1000, 451,-1000,-1000,  13,-1000,
 546, 524, 502, 490, 465, 443, 431, 406, 384,-1000,
-1000, 858, 372, 425,-270,-1000, 858, 451,  12,  12,
  12, 451, 313,-1000, 313,  16, 350, 313,  16,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,  84,-1000,
 451,-1000,-1000,-1000,-1000,  25,-1000,  25,-1000,-1000,
-1000, -77,-1000, -77,-1000, -77,-1000,  -6,-1000,  -6,
-1000,  -6,-1000, -30, 313, 122, -30,-1000,-1000,-1000,
-1000,-1000, 451,-1000,-1000,-1000, 451, 313,-1000,-1000,
-1000,  16,-1000, 451,-1000,-1000,-1000, 313,-1000, -10,
-1000,-1000,  34,-1000,-1000,-1000,-1000,-1000,-1000 };
short yypgo[]={

   0, 102,  19,   9, 100,1141, 439,  99,  91,  89,
  84,  31,  18,  82,  80,  73,  69,  28,  10,  65,
  62,  60,  29,  56,  54,  53,  51,  50,  47, 109,
  45,  43,  42,  40,  13,  32,  27,  25 };
short yyr1[]={

   0,   1,   1,   1,   2,   2,   2,   2,   2,   2,
   2,   2,   2,   2,   2,   2,   2,   2,   2,   4,
   4,   4,   5,   5,  13,  10,  10,  11,  11,  12,
  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,
  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,
  12,  12,  12,  12,  12,  12,  12,  12,  12,  12,
  12,  12,  17,  17,   9,   9,   9,   9,   9,   9,
  19,  19,  21,  21,  21,  21,  21,  21,  21,  21,
  21,  21,  21,  21,  21,  21,  21,  20,  20,  22,
  14,  14,  24,  24,  28,  28,  25,  26,  26,  26,
  26,  27,  27,  23,  29,  29,  29,  15,  15,  15,
  30,  31,  32,  33,  35,  36,  36,  34,   8,  37,
  37,   7,   7,  18,  18,   6,   6,   6,   3,   3,
  16,  16 };
short yyr2[]={

   0,   0,   2,   2,   2,   2,   3,   2,   4,   2,
   5,   2,   1,   2,   4,   2,   1,   1,   2,   1,
   1,   1,   1,   1,   1,   1,   1,   1,   1,   3,
   3,   2,   2,   2,   1,   1,   2,   3,   2,   3,
   3,   3,   3,   2,   2,   3,   3,   3,   3,   3,
   3,   3,   3,   3,   3,   3,   3,   3,   3,   4,
   4,   3,   1,   2,   3,   2,   3,   2,   3,   2,
   2,   2,   1,   1,   1,   1,   1,   1,   1,   1,
   1,   1,   1,   1,   1,   1,   1,   1,   2,   2,
   5,   2,   0,   1,   1,   2,   1,   0,   3,   2,
   2,   1,   2,   1,   0,   2,   2,   1,   1,   1,
   3,   3,   3,   2,   3,   4,   2,   1,   3,   4,
   3,   0,   1,   1,   1,   1,   1,   0,   1,   1,
   1,   1 };
short yychk[]={

-1000,  -1,  -2, 256, 267, 269,  -4, 275, 280,  -3,
 276, 273,  -8,  -9, -10, 262,  10,  59, -37, -19,
 -11, -12, 266, 268, 265, -14, -15, 259, 260, 261,
 264,  34,  91,  58,  -5,  45, 123,  40, -23, -30,
 -31, -32, 270, -33, -35, -36, 277, 279,  -3,  -3,
  -5, 256, -11, -12, 266,  -5, 256,  -5, 256,  -6,
  10,  59,  -7, 256, 265,  -6, -29, -20,  10, 124,
 256, -22,  58,  -5, 256,  -5, 270, -21, 261, 260,
 259, 276, 262, 275, 280, 266, 265, 267, 268, 273,
 277, 279, 271,  -5, 256,  -5, 256, 263, 274, 263,
  43,  45,  94,  42,  47,  92,  61,  60,  62,  -5,
 256, 259, 259,  -5, -24, 256, -28,  -5, -29, -29,
 -29,  -5,  -5,  -6,  -5,  -5,  45,  -5,  -5,  -2,
 256, -34, 278,  10, 124, 256, -22, 263,  -5,  -6,
  -5, 256, -16,  93,  10,  -5, 256,  -5, 256,  -5,
 256,  -5, 256,  -5, 256,  -5, 256,  -5, 256,  -5,
 256,  -5, 256, -17,  -5,  -5, -17, -18, 125,  41,
 -25, 272,  -5, -34, -34, -34,  -5,  -5,  -6,  -5,
 256,  -5,  -6,  -5,  -3, -18, -17,  -5, -18, -26,
  -6, -27, -13,  -2, 256, 271, 264,  -2, 271 };
short yydef[]={

   1,  -2,   2,   3,  20,  21,   0,   0,   0,  12,
 127, 121,  16,  17, 127,  19, 128, 129, 104,   0,
  -2,  -2,   0,   0,   0,  27,  28,   0,   0,  34,
  35,   0,   0,   0,   0,   0,   0,   0,  92, 107,
 108, 109, 103, 104, 104, 104,   0,   0,   4,   5,
 127,   7,  22,  23,   0,   0,   9,   0,  11,  13,
 125, 126,   0,  15, 122,  18,   0,   0,  65,  67,
  69,  87,   0,   0, 116, 127,  70,  71,  72,  73,
  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,
  84,  85,  86,   0,  31,  32,  33,  36,   0,  38,
   0,   0,   0,   0,   0,   0,   0,   0,   0,  43,
  44,   0,   0,   0,   0,  91,  93,  94,   0,   0,
   0, 113,   0,   6,   0, 127,   0,   0, 127, 105,
 106, 118, 117,  64,  66,  68,  88,  89,   0, 120,
  29,  30,  37, 130, 131,  39,  40,  41,  42,  45,
  46,  47,  48,  49,  50,  51,  52,  -2,  54,  -2,
  56,  -2,  58,   0,  62,  62,   0,  61, 123, 124,
  97,  96,  95, 110, 111, 112, 114,   0,   8,  -2,
  -2, 127,  14, 115, 119,  59,  63,  29,  60,   0,
  10,  90,   0,  99, 100, 101,  -2,  98, 102 };
# line 1 "/usr/lib/yaccpar"
#ifndef lint
static char yaccpar_sccsid[] = "@(#)yaccpar	4.1	(Berkeley)	2/11/83";
#endif not lint

# define YYFLAG -1000
# define YYERROR goto yyerrlab
# define YYACCEPT return(0)
# define YYABORT return(1)

/*	parser for yacc output	*/

#ifdef YYDEBUG
int yydebug = 0; /* 1 for debugging */
#endif
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
int yychar = -1; /* current input token number */
int yynerrs = 0;  /* number of errors */
short yyerrflag = 0;  /* error recovery flag */

yyparse() {

	short yys[YYMAXDEPTH];
	short yyj, yym;
	register YYSTYPE *yypvt;
	register short yystate, *yyps, yyn;
	register YYSTYPE *yypv;
	register short *yyxi;

	yystate = 0;
	yychar = -1;
	yynerrs = 0;
	yyerrflag = 0;
	yyps= &yys[-1];
	yypv= &yyv[-1];

 yystack:    /* put a state and value onto the stack */

#ifdef YYDEBUG
	if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
#endif
		if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
		*yyps = yystate;
		++yypv;
		*yypv = yyval;

 yynewstate:

	yyn = yypact[yystate];

	if( yyn<= YYFLAG ) goto yydefault; /* simple state */

	if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
	if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;

	if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
		yychar = -1;
		yyval = yylval;
		yystate = yyn;
		if( yyerrflag > 0 ) --yyerrflag;
		goto yystack;
		}

 yydefault:
	/* default state action */

	if( (yyn=yydef[yystate]) == -2 ) {
		if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
		/* look through exception table */

		for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */

		while( *(yyxi+=2) >= 0 ){
			if( *yyxi == yychar ) break;
			}
		if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
		}

	if( yyn == 0 ){ /* error */
		/* error ... attempt to resume parsing */

		switch( yyerrflag ){

		case 0:   /* brand new error */

			yyerror( "syntax error" );
		yyerrlab:
			++yynerrs;

		case 1:
		case 2: /* incompletely recovered error ... try again */

			yyerrflag = 3;

			/* find a state where "error" is a legal shift action */

			while ( yyps >= yys ) {
			   yyn = yypact[*yyps] + YYERRCODE;
			   if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
			      yystate = yyact[yyn];  /* simulate a shift of "error" */
			      goto yystack;
			      }
			   yyn = yypact[*yyps];

			   /* the current yyps has no shift onn "error", pop stack */

#ifdef YYDEBUG
			   if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
#endif
			   --yyps;
			   --yypv;
			   }

			/* there is no state on the stack with an error shift ... abort */

	yyabort:
			return(1);


		case 3:  /* no shift yet; clobber input char */

#ifdef YYDEBUG
			if( yydebug ) printf( "error recovery discards char %d\n", yychar );
#endif

			if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
			yychar = -1;
			goto yynewstate;   /* try again in the same state */

			}

		}

	/* reduction by production yyn */

#ifdef YYDEBUG
		if( yydebug ) printf("reduce %d\n",yyn);
#endif
		yyps -= yyr2[yyn];
		yypvt = yypv;
		yypv -= yyr2[yyn];
		yyval = yypv[1];
		yym=yyn;
			/* consult goto table to find next state */
		yyn = yyr1[yyn];
		yyj = yypgo[yyn] + *yyps + 1;
		if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
		switch(yym){
			
case 2:
# line 281 "logo.y"
{
		popname[0] = '\0';
#ifdef NEXT
	        if(ibufptr == NULL)
                 return(0);
#endif NEXT
#ifdef PAUSE
		if (psigflag) dopause();
#endif
		yyprompt(1);
	} break;
case 3:
# line 292 "logo.y"
{
		popname[0] = '\0';
		if (!errtold) {
			logoyerror();
		}
		errtold = 0;
		errwhere();
#ifdef PAUSE
		if ((!errpause&&!pauselev) || !fbr)
#endif
			errzap();
		yyerrok;yyclearin;
		yyprompt(0);
	} break;
case 4:
# line 307 "logo.y"
{
		catch(doedit(););
		yyval = -1;
	} break;
case 5:
# line 311 "logo.y"
{
		catch(ltrace(););
		yyval = -1;
	} break;
case 6:
# line 315 "logo.y"
{
		catch(yyval=(int)(*keywords[yypvt[-2]].lexval)(yypvt[-1]););} break;
case 7:
# line 317 "logo.y"
{notenf(yypvt[-1]);uperror;} break;
case 8:
# line 318 "logo.y"
{
		catch((*keywords[yypvt[-3]].lexval)(yypvt[-2],yypvt[-1]);); yyval = -1;} break;
case 9:
# line 320 "logo.y"
{notenf(yypvt[-1]);uperror;} break;
case 10:
# line 321 "logo.y"
{
#ifndef SMALL
		catch(pprop(yypvt[-3],yypvt[-2],yypvt[-1]););
#endif
		yyval = -1;
	} break;
case 11:
# line 327 "logo.y"
{
		if (!errtold) {
			puts("Not enough inputs to pprop.");
		}
		uperror;
	} break;
case 12:
# line 333 "logo.y"
{ yyval= -1; } break;
case 13:
# line 334 "logo.y"
{
		catch((*keywords[yypvt[-1]].lexval)();); yyval= -1;} break;
case 14:
# line 336 "logo.y"
{
		catch(go(yypvt[-1]););
		yyval= -1;
		} break;
case 15:
# line 340 "logo.y"
{notenf(yypvt[-1]);uperror;} break;
case 16:
# line 341 "logo.y"
{
		if ((yypvt[-0] != -1) && !endflag) {
			if (!errtold)
				pf1("You don't say what to do with %l.\n",yypvt[-0]);
			uperror;
		}
		yyval = yypvt[-0];
	} break;
case 17:
# line 349 "logo.y"
{
		if (yypvt[-0]== -1)
			uperror
		else
			catch(proccreate(yypvt[-0]););
			yyval = -1;
	} break;
case 18:
# line 356 "logo.y"
{
		if (thisrun && !pflag) {
			yyval = yypvt[-1];
		} else {
			if((yypvt[-1] != -1) && !endflag) {
				if (!errtold)
					pf1("You don't say what to do with %l\n",yypvt[-1]);
				uperror;
			}
		}
	} break;
case 22:
# line 370 "logo.y"
{
			if (yypvt[-0] == -1) {
				if (!errtold) {
					printf("%s didn't output.\n",
						popname);
				}
				uperror;
			}
		} break;
case 24:
# line 381 "logo.y"
{ yyline=((struct object *)yypvt[-0])->obint; mfree(yypvt[-0]); yyval = 0;} break;
case 29:
# line 388 "logo.y"
{
		catch(yyval=(int)(*keywords[yypvt[-2]].lexval)(yypvt[-1],yypvt[-0]););
	} break;
case 30:
# line 391 "logo.y"
{op2er1(yypvt[-2],yypvt[-1]);uperror;} break;
case 31:
# line 392 "logo.y"
{notenf(yypvt[-1]);uperror;} break;
case 32:
# line 393 "logo.y"
{
		catch(yyval=(int)(*keywords[yypvt[-1]].lexval)(yypvt[-0]););
	} break;
case 33:
# line 396 "logo.y"
{notenf(yypvt[-1]);uperror;} break;
case 34:
# line 397 "logo.y"
{
		catch(yyval=(int)(*keywords[yypvt[-0]].lexval)(););
	} break;
case 36:
# line 401 "logo.y"
{ yyval=yypvt[-0]; } break;
case 37:
# line 402 "logo.y"
{ yyval=yypvt[-1]; } break;
case 38:
# line 403 "logo.y"
{
		catch(yyval=(int)alllk(yypvt[-0]););
		} break;
case 39:
# line 406 "logo.y"
{
		catch(yyval=(int)add(yypvt[-2],yypvt[-0]););
	} break;
case 40:
# line 409 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 41:
# line 410 "logo.y"
{
		catch(yyval=(int)sub(yypvt[-2],yypvt[-0]););
	} break;
case 42:
# line 413 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 43:
# line 414 "logo.y"
{
		catch(yyval=(int)opp(yypvt[-0]););
	} break;
case 44:
# line 417 "logo.y"
{unerr('-');uperror;} break;
case 45:
# line 418 "logo.y"
{
		catch(yyval=(int)lpow(yypvt[-2],yypvt[-0]););
	} break;
case 46:
# line 421 "logo.y"
{ inferr(yypvt[-2],yypvt[-1]);uperror; } break;
case 47:
# line 422 "logo.y"
{
		catch(yyval=(int)mult(yypvt[-2],yypvt[-0]););
	} break;
case 48:
# line 425 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 49:
# line 426 "logo.y"
{
		catch(yyval=(int)div(yypvt[-2],yypvt[-0]););
	} break;
case 50:
# line 429 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 51:
# line 430 "logo.y"
{
		catch(yyval=(int)rem(yypvt[-2],yypvt[-0]););
	} break;
case 52:
# line 433 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 53:
# line 434 "logo.y"
{
		catch(yyval=(int)equal(yypvt[-2],yypvt[-0]);)
	} break;
case 54:
# line 437 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 55:
# line 438 "logo.y"
{
		catch(yyval=(int)lessp(yypvt[-2],yypvt[-0]););
	} break;
case 56:
# line 441 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 57:
# line 442 "logo.y"
{
		catch(yyval=(int)greatp(yypvt[-2],yypvt[-0]););
	} break;
case 58:
# line 445 "logo.y"
{inferr(yypvt[-2],yypvt[-1]);uperror;} break;
case 59:
# line 446 "logo.y"
{
		catch(yyval=multiop(yypvt[-2],globcopy(multarg)););
		lfree(multarg);
		multarg = 0;
	} break;
case 60:
# line 451 "logo.y"
{
		catch(yyval=multiop(yypvt[-2],globcopy(multarg)););
		lfree(multarg);
		multarg = 0;
	} break;
case 61:
# line 456 "logo.y"
{yyval=yypvt[-1];} break;
case 62:
# line 458 "logo.y"
{
		catch(multarg = globcons(yypvt[-0],0););
		mfree(yypvt[-0]);
		multnum = 1;
	} break;
case 63:
# line 463 "logo.y"
{
		catch(multarg = globcons(yypvt[-1],multarg););
		mfree(yypvt[-1]);
		multnum++;
	} break;
case 64:
# line 468 "logo.y"
{
		strcpy(titleptr,"\n");
		yyval=yypvt[-2];
	} break;
case 65:
# line 472 "logo.y"
{
		strcpy(titleptr,"\n");
		yyval=yypvt[-1];
	} break;
case 66:
# line 477 "logo.y"
{
		strcpy(titleptr,"\n");
		yyval=yypvt[-2];
	} break;
case 67:
# line 481 "logo.y"
{
		strcpy(titleptr,"\n");
		yyval=yypvt[-1];
	} break;
case 68:
# line 485 "logo.y"
{
		mfree(yypvt[-2]);
		terr();
		yyval= -1;
	} break;
case 69:
# line 490 "logo.y"
{
		mfree(yypvt[-1]);
		terr();
		yyval= -1;
	} break;
case 70:
# line 495 "logo.y"
{
              		titleptr=cpystr(titlebuf,"to ",
			((struct object *)(yypvt[-0]))->obstr,NULL);
		yyval=yypvt[-0];
	} break;
case 71:
# line 500 "logo.y"
{
		if (!errtold) printf("Can't redefine primitive %s\n",
			keywords[yypvt[-0]].word);
		uperror;
	} break;
case 87:
# line 508 "logo.y"
{titleptr=cpystr(titleptr," :",
			((struct object *)(yypvt[-0]))->obstr,NULL);
		mfree(yypvt[-0]);
	} break;
case 88:
# line 512 "logo.y"
{titleptr=cpystr(titleptr," :",
			((struct object *)(yypvt[-0]))->obstr,NULL);
		mfree(yypvt[-0]);
	} break;
case 89:
# line 516 "logo.y"
{yyval=yypvt[-0];} break;
case 90:
# line 517 "logo.y"
{
		yyval=yypvt[-1];
		frmpop(yypvt[-1]);
	} break;
case 91:
# line 521 "logo.y"
{
		if (!errtold) printf("Not enough inputs to %s\n",
			proclist->procname->obstr);
		uperror;
	} break;
case 94:
# line 527 "logo.y"
{
		catch(argassign(yypvt[-0]););
	} break;
case 95:
# line 530 "logo.y"
{
		catch(argassign(yypvt[-0]););
	} break;
case 96:
# line 533 "logo.y"
{procprep();} break;
case 97:
# line 534 "logo.y"
{yyline=1; yyval = -1;} break;
case 98:
# line 535 "logo.y"
{
		popname[0] = '\0';
#ifdef PAUSE
		if (psigflag) dopause();
		if (thisrun && thisrun->str == (struct object *)(-1))
			yyprompt(1);
#endif
		yyval=yypvt[-0];
	} break;
case 99:
# line 544 "logo.y"
{
		popname[0] = '\0';
		if (pflag) yyline++;
#ifdef PAUSE
		if (psigflag) dopause();
		if (thisrun && thisrun->str == (struct object *)(-1))
			yyprompt(1);
#endif
		yyval=yypvt[-0];
	} break;
case 100:
# line 554 "logo.y"
{
		popname[0] = '\0';
#ifdef PAUSE
		if ((!errpause&&!pauselev) || !fbr)
#endif
			uperror;
#ifdef PAUSE
		if (!errtold) {
			logoyerror();
		}
		errtold = 0;
		errwhere();
		yyerrok;yyclearin;
		if (thisrun && thisrun->str == (struct object *)(-1))
			yyprompt(0);
#endif
	} break;
case 103:
# line 573 "logo.y"
{
		catch(newproc(yypvt[-0]););
	} break;
case 104:
# line 576 "logo.y"
{yyval = -1;} break;
case 105:
# line 577 "logo.y"
{
		popname[0] = '\0';
#ifdef PAUSE
		if (psigflag) dopause();
		if (thisrun && thisrun->str == (struct object *)(-1))
			yyprompt(1);
#endif
		yyval=yypvt[-0];
	} break;
case 106:
# line 586 "logo.y"
{
		popname[0] = '\0';
#ifdef PAUSE
		if ((!errpause&&!pauselev) || !fbr)
#endif
			uperror;
#ifdef PAUSE
		if (!errtold) {
			logoyerror();
		}
		errtold = 0;
		errwhere();
		yyerrok;yyclearin;
		if (thisrun && thisrun->str == (struct object *)(-1))
			yyprompt(0);
#endif
	} break;
case 110:
# line 604 "logo.y"
{
		unrun();
		yyval = yypvt[-1];
		strcpy(popname,"run");
	} break;
case 111:
# line 609 "logo.y"
{
		unrun();
		yyval = yypvt[-1];
		strcpy(popname,"repeat");
	} break;
case 112:
# line 614 "logo.y"
{
		unrun();
		yyval = yypvt[-1];
		strcpy(popname,"if");
	} break;
case 113:
# line 619 "logo.y"
{
		catch(dorun(yypvt[-0],(FIXNUM)0););
	} break;
case 114:
# line 622 "logo.y"
{
		catch(dorep(yypvt[-1],yypvt[-0]););
	} break;
case 115:
# line 625 "logo.y"
{
		{
			int i;

			catch(i = truth(yypvt[-2]););
			if (i) {
				catch(dorun(yypvt[-1],(FIXNUM)0););
				mfree(yypvt[-0]);
			} else {
				catch(dorun(yypvt[-0],(FIXNUM)0););
				mfree(yypvt[-1]);
			}
		}
	} break;
case 116:
# line 639 "logo.y"
{
		if (!errtold) printf("Not enough inputs to if.\n");
		uperror;
	} break;
case 118:
# line 644 "logo.y"
{
		unrun();
		yyval = yypvt[-1];
	} break;
case 119:
# line 648 "logo.y"
{
		{
			int i;

			catch(i = truth(yypvt[-2]););
			if (i) {catch(dorun(yypvt[-1],(FIXNUM)0););}
			else {
				catch(dorun(0,(FIXNUM)0););
				mfree(yypvt[-1]);
			}
		}
	} break;
case 120:
# line 660 "logo.y"
{
		if ((int)keywords[yypvt[-2]].lexval==currtest) {
			catch(dorun(yypvt[-1],(FIXNUM)0););
		} else {
			catch(dorun(0,(FIXNUM)0););
			mfree(yypvt[-1]);
		}
	} break;
# line 148 "/usr/lib/yaccpar"

		}
		goto yystack;  /* stack new state and value */

	}
