www.pudn.com > subpas.rar > parse.c

/**************************************************************************** 
*                     U N R E G I S T E R E D   C O P Y 
*  
* You are on day 60 of your 30 day trial period. 
*  
* This file was produced by an UNREGISTERED COPY of Parser Generator. It is 
* for evaluation purposes only. If you continue to use Parser Generator 30 
* days after installation then you are required to purchase a license. For 
* more information see the online help or go to the Bumble-Bee Software 
* homepage at: 
*  
* http://www.bumblebeesoftware.com 
*  
* This notice must remain present in the file. It cannot be removed. 
****************************************************************************/ 
 
/**************************************************************************** 
* parse.c 
* C source file generated from parse.y. 
*  
* Date: 08/29/05 
* Time: 23:35:14 
*  
* AYACC Version: 2.07 
****************************************************************************/ 
 
#include  
 
/* namespaces */ 
#if defined(__cplusplus) && defined(YYSTDCPPLIB) 
using namespace std; 
#endif 
#if defined(__cplusplus) && defined(YYNAMESPACE) 
using namespace yl; 
#endif 
 
#define YYFASTPARSER 
 
#line 6 ".\\parse.y" 
 
#define YYPARSER /* distinguishes Yacc output from other code files */ 
#include "globals.h" 
#include "util.h" 
#include "scan.h" 
#include "parse.h" 
 
static ArrayAttr * savedArray; 
static char * savedName; /* for use in assignments */ 
static char * savedProName; 
static char * savedMainName; 
static int savedLow; 
static int savedHigh; 
static int savedType; 
static int savedLineno; 
static TreeNode * savedTree; /* stores syntax tree for later return */ 
 
 
#line 59 "parse.c" 
/* repeated because of possible precompiled header */ 
#include  
 
/* namespaces */ 
#if defined(__cplusplus) && defined(YYSTDCPPLIB) 
using namespace std; 
#endif 
#if defined(__cplusplus) && defined(YYNAMESPACE) 
using namespace yl; 
#endif 
 
#define YYFASTPARSER 
 
#include ".\parse.h" 
 
#ifndef YYSTYPE 
#define YYSTYPE int 
#endif 
#ifndef YYSTACK_SIZE 
#define YYSTACK_SIZE 100 
#endif 
#ifndef YYSTACK_MAX 
#define YYSTACK_MAX 0 
#endif 
 
/* (state) stack */ 
#if (YYSTACK_SIZE) != 0 
static yystack_t YYNEAR yystack[(YYSTACK_SIZE)]; 
yystack_t YYFAR *YYNEAR YYDCDECL yysstackptr = yystack; 
yystack_t YYFAR *YYNEAR YYDCDECL yystackptr = yystack; 
#else 
yystack_t YYFAR *YYNEAR YYDCDECL yysstackptr = NULL; 
yystack_t YYFAR *YYNEAR YYDCDECL yystackptr = NULL; 
#endif 
 
/* attribute stack */ 
#if (YYSTACK_SIZE) != 0 
static YYSTYPE YYNEAR yyattributestack[(YYSTACK_SIZE)]; 
#ifdef YYPROTOTYPE 
void YYFAR *YYNEAR YYDCDECL yysattributestackptr = yyattributestack; 
void YYFAR *YYNEAR YYDCDECL yyattributestackptr = yyattributestack; 
#else 
char YYFAR *YYNEAR YYDCDECL yysattributestackptr = (char YYFAR *) yyattributestack; 
char YYFAR *YYNEAR YYDCDECL yyattributestackptr = (char YYFAR *) yyattributestack; 
#endif 
#else 
#ifdef YYPROTOTYPE 
void YYFAR *YYNEAR YYDCDECL yysattributestackptr = NULL; 
void YYFAR *YYNEAR YYDCDECL yyattributestackptr = NULL; 
#else 
char YYFAR *YYNEAR YYDCDECL yysattributestackptr = NULL; 
char YYFAR *YYNEAR YYDCDECL yyattributestackptr = NULL; 
#endif 
#endif 
 
int YYNEAR YYDCDECL yysstack_size = (YYSTACK_SIZE); 
int YYNEAR YYDCDECL yystack_size = (YYSTACK_SIZE); 
int YYNEAR YYDCDECL yystack_max = (YYSTACK_MAX); 
 
/* attributes */ 
YYSTYPE YYNEAR yyval; 
YYSTYPE YYNEAR yylval; 
#ifdef YYPROTOTYPE 
void YYFAR *YYNEAR YYDCDECL yyvalptr = &yyval; 
void YYFAR *YYNEAR YYDCDECL yylvalptr = &yylval; 
#else 
char YYFAR *YYNEAR YYDCDECL yyvalptr = (char *) &yyval; 
char YYFAR *YYNEAR YYDCDECL yylvalptr = (char *) &yylval; 
#endif 
 
size_t YYNEAR YYDCDECL yyattribute_size = sizeof(YYSTYPE); 
 
/* yyattribute */ 
#ifdef YYDEBUG 
#ifdef YYPROTOTYPE 
static YYSTYPE YYFAR *yyattribute1(int index) 
#else 
static YYSTYPE YYFAR *yyattribute1(index) 
int index; 
#endif 
{ 
	YYSTYPE YYFAR *p = &((YYSTYPE YYFAR *) yyattributestackptr)[yytop + index]; 
	return p; 
} 
#define yyattribute(index) (*yyattribute1(index)) 
#else 
#define yyattribute(index) (((YYSTYPE YYFAR *) yyattributestackptr)[yytop + (index)]) 
#endif 
 
#ifdef YYDEBUG 
#ifdef YYPROTOTYPE 
static void yyinitdebug(YYSTYPE YYFAR **p, int count) 
#else 
static void yyinitdebug(p, count) 
YYSTYPE YYFAR **p; 
int count; 
#endif 
{ 
	int i; 
	yyassert(p != NULL); 
	yyassert(count >= 1); 
 
	for (i = 0; i < count; i++) { 
		p[i] = &((YYSTYPE YYFAR *) yyattributestackptr)[yytop + i - (count - 1)]; 
	} 
} 
#endif 
 
#ifdef YYPROTOTYPE 
void YYCDECL yyparseraction(int action) 
#else 
void YYCDECL yyparseraction(action) 
int action; 
#endif 
{ 
	switch (action) { 
	case 0: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 54 ".\\parse.y" 
savedMainName = copyString(tokenString); 
#line 185 "parse.c" 
			} 
		} 
		break; 
	case 1: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[11]; 
			yyinitdebug(yya, 11); 
#endif 
			{ 
#line 59 ".\\parse.y" 
 
              yyval.ptree = newProNode(MainP); 
              yyval.ptree->child[1] = yyattribute(8 - 10).ptree; 
              yyval.ptree->sibling = yyattribute(9 - 10).ptree; 
              yyval.ptree->child[2] = yyattribute(10 - 10).ptree; 
              yyval.ptree->name = savedMainName; 
              savedTree = yyval.ptree; 
             
#line 205 "parse.c" 
			} 
		} 
		break; 
	case 2: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 69 ".\\parse.y" 
 yyval.ptree = newExpNode(IdK); 
                       yyval.ptree->name = copyString(tokenString);     
                      
#line 220 "parse.c" 
			} 
		} 
		break; 
	case 3: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 73 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 3).ptree; 
						yyattribute(3 - 3).ptree = newExpNode(IdK); 
						yyattribute(3 - 3).ptree->name = savedName; 
		 
                        if (t != NULL){ 
                          while (t->sibling != NULL) 
                            t = t->sibling; 
                          t->sibling = yyattribute(3 - 3).ptree; 
                          yyval.ptree = yyattribute(1 - 3).ptree; } 
                        else yyval.ptree = yyattribute(3 - 3).ptree; 
                       
#line 243 "parse.c" 
			} 
		} 
		break; 
	case 4: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 85 ".\\parse.y" 
 savedName = copyString(tokenString); 
		  yyval.ptree=NULL; 
#line 257 "parse.c" 
			} 
		} 
		break; 
	case 5: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 88 ".\\parse.y" 
 yyval.ptree=yyattribute(2 - 3).ptree;  
#line 270 "parse.c" 
			} 
		} 
		break; 
	case 6: 
		{ 
#line 89 ".\\parse.y" 
yyval.ptree=NULL; 
#line 278 "parse.c" 
		} 
		break; 
	case 7: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 92 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 5).ptree; 
                    if (t != NULL){ 
                      while (t->sibling != NULL) 
                        t = t->sibling; 
                      t->sibling = yyattribute(3 - 5).ptree; 
                      yyval.ptree = yyattribute(1 - 5).ptree; } 
                    else yyval.ptree = yyattribute(3 - 5).ptree; 
                    t = yyattribute(3 - 5).ptree; 
                    while(t != NULL){ 
                      t->type=yyattribute(5 - 5).dtype; 
                      if(yyattribute(5 - 5).dtype == Array) t->attr.arrayattr=savedArray; 
                      t=t->sibling; 
                    }                
                   
#line 303 "parse.c" 
			} 
		} 
		break; 
	case 8: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 107 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 3).ptree; 
                     while(t != NULL){ 
                        t->type=yyattribute(3 - 3).dtype; 
                        if(yyattribute(3 - 3).dtype == Array) t->attr.arrayattr=savedArray; 
                        t=t->sibling;  
                     } 
                     yyval.ptree = yyattribute(1 - 3).ptree; 
                   
#line 323 "parse.c" 
			} 
		} 
		break; 
	case 9: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 116 ".\\parse.y" 
yyval.dtype=yyattribute(1 - 1).dtype; 
#line 336 "parse.c" 
			} 
		} 
		break; 
	case 10: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 117 ".\\parse.y" 
savedLow=atoi(tokenString); 
#line 349 "parse.c" 
			} 
		} 
		break; 
	case 11: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[8]; 
			yyinitdebug(yya, 8); 
#endif 
			{ 
#line 118 ".\\parse.y" 
savedHigh=atoi(tokenString); 
#line 362 "parse.c" 
			} 
		} 
		break; 
	case 12: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[12]; 
			yyinitdebug(yya, 12); 
#endif 
			{ 
#line 120 ".\\parse.y" 
 
            yyval.dtype=Array; 
            savedArray = (ArrayAttr *)malloc(sizeof(ArrayAttr)); 
            savedArray->type = yyattribute(11 - 11).dtype; 
            savedArray->low = savedLow; 
            savedArray->high = savedHigh; 
            savedArray->count = savedHigh - savedLow + 1; 
          
#line 382 "parse.c" 
			} 
		} 
		break; 
	case 13: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 129 ".\\parse.y" 
yyval.dtype=Integer; 
#line 395 "parse.c" 
			} 
		} 
		break; 
	case 14: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 130 ".\\parse.y" 
yyval.dtype=Real; 
#line 408 "parse.c" 
			} 
		} 
		break; 
	case 15: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 131 ".\\parse.y" 
yyval.dtype=Boolean; 
#line 421 "parse.c" 
			} 
		} 
		break; 
	case 16: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 134 ".\\parse.y" 
TreeNode* t=yyattribute(1 - 3).ptree; 
                           if (t != NULL){ 
                              while (t->sibling != NULL) 
                                  t = t->sibling; 
                               t->sibling = yyattribute(2 - 3).ptree; 
                               yyval.ptree = yyattribute(1 - 3).ptree; } 
                              else yyval.ptree = yyattribute(2 - 3).ptree;                
                           
#line 441 "parse.c" 
			} 
		} 
		break; 
	case 17: 
		{ 
#line 142 ".\\parse.y" 
  yyval.ptree=NULL;   
#line 449 "parse.c" 
		} 
		break; 
	case 18: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 147 ".\\parse.y" 
 
                            yyval.ptree = newProNode(SubP); 
                            yyval.ptree->name = savedProName; 
                            yyval.ptree->type = savedType; 
                            yyval.ptree->child[0] = yyattribute(1 - 3).ptree; 
                            yyval.ptree->child[1] = yyattribute(2 - 3).ptree; 
                            yyval.ptree->child[2] = yyattribute(3 - 3).ptree;                         
                           
#line 468 "parse.c" 
			} 
		} 
		break; 
	case 19: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 156 ".\\parse.y" 
savedProName=copyString(tokenString); 
#line 481 "parse.c" 
			} 
		} 
		break; 
	case 20: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[8]; 
			yyinitdebug(yya, 8); 
#endif 
			{ 
#line 158 ".\\parse.y" 
  yyval.ptree=yyattribute(4 - 7).ptree; 
                        savedType=yyattribute(6 - 7).dtype;                        
                       
#line 496 "parse.c" 
			} 
		} 
		break; 
	case 21: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 161 ".\\parse.y" 
savedProName=copyString(tokenString); 
#line 509 "parse.c" 
			} 
		} 
		break; 
	case 22: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 163 ".\\parse.y" 
   yyval.ptree=yyattribute(4 - 5).ptree; 
                        savedType=Void; 
                     
#line 524 "parse.c" 
			} 
		} 
		break; 
	case 23: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 167 ".\\parse.y" 
yyval.ptree = yyattribute(2 - 3).ptree;  
#line 537 "parse.c" 
			} 
		} 
		break; 
	case 24: 
		{ 
#line 168 ".\\parse.y" 
yyval.ptree = NULL; 
#line 545 "parse.c" 
		} 
		break; 
	case 25: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 171 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 3).ptree; 
                    while(t != NULL){ 
                      t->type=yyattribute(3 - 3).dtype; 
                      t->attr.paramkind=ByVal; 
                      t=t->sibling;  
                    } 
                    yyval.ptree=yyattribute(1 - 3).ptree; 
                   
#line 564 "parse.c" 
			} 
		} 
		break; 
	case 26: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 180 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 5).ptree; 
                    if (t != NULL){ 
                      while (t->sibling != NULL) 
                        t = t->sibling; 
                      t->sibling = yyattribute(3 - 5).ptree; 
                      yyval.ptree = yyattribute(1 - 5).ptree; } 
                    else yyval.ptree = yyattribute(3 - 5).ptree; 
                    t = yyattribute(3 - 5).ptree; 
                    while(t != NULL){ 
                      t->type=yyattribute(5 - 5).dtype; 
                      t->attr.paramkind=ByVal; 
                      t=t->sibling; 
                    }                
                   
#line 590 "parse.c" 
			} 
		} 
		break; 
	case 27: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[5]; 
			yyinitdebug(yya, 5); 
#endif 
			{ 
#line 195 ".\\parse.y" 
 TreeNode * t = yyattribute(2 - 4).ptree; 
                    while(t != NULL){ 
                      t->type=yyattribute(4 - 4).dtype; 
                      t->attr.paramkind=ByRefer; 
                      t=t->sibling;  
                    } 
                    yyval.ptree=yyattribute(2 - 4).ptree; 
                   
#line 610 "parse.c" 
			} 
		} 
		break; 
	case 28: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[7]; 
			yyinitdebug(yya, 7); 
#endif 
			{ 
#line 204 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 6).ptree; 
                    if (t != NULL){ 
                      while (t->sibling != NULL) 
                        t = t->sibling; 
                      t->sibling = yyattribute(4 - 6).ptree; 
                      yyval.ptree = yyattribute(1 - 6).ptree; } 
                    else yyval.ptree = yyattribute(4 - 6).ptree; 
                    t = yyattribute(4 - 6).ptree; 
                    while(t != NULL){ 
                      t->type=yyattribute(6 - 6).dtype; 
                      t->attr.paramkind=ByRefer; 
                      t=t->sibling; 
                    }                
                   
#line 636 "parse.c" 
			} 
		} 
		break; 
	case 29: 
		{ 
#line 218 ".\\parse.y" 
yyval.ptree = NULL; 
#line 644 "parse.c" 
		} 
		break; 
	case 30: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 223 ".\\parse.y" 
yyval.ptree=yyattribute(2 - 3).ptree; 
#line 656 "parse.c" 
			} 
		} 
		break; 
	case 31: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 225 ".\\parse.y" 
yyval.ptree=yyattribute(1 - 2).ptree; 
#line 669 "parse.c" 
			} 
		} 
		break; 
	case 32: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 226 ".\\parse.y" 
yyval.ptree=yyattribute(1 - 1).ptree; 
#line 682 "parse.c" 
			} 
		} 
		break; 
	case 33: 
		{ 
#line 227 ".\\parse.y" 
yyval.ptree=NULL; 
#line 690 "parse.c" 
		} 
		break; 
	case 34: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 229 ".\\parse.y" 
yyval.ptree=yyattribute(1 - 1).ptree; 
#line 702 "parse.c" 
			} 
		} 
		break; 
	case 35: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 231 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 3).ptree; 
                    if (t != NULL){ 
                      while (t->sibling != NULL) 
                        t = t->sibling; 
                      t->sibling = yyattribute(3 - 3).ptree; 
                      yyval.ptree = yyattribute(1 - 3).ptree; } 
                    else yyval.ptree = yyattribute(3 - 3).ptree; 
                   
#line 722 "parse.c" 
			} 
		} 
		break; 
	case 36: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 240 ".\\parse.y" 
savedLineno = lineno; 
#line 735 "parse.c" 
			} 
		} 
		break; 
	case 37: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[5]; 
			yyinitdebug(yya, 5); 
#endif 
			{ 
#line 241 ".\\parse.y" 
yyval.ptree = newStmtNode(AssignK); 
               yyval.ptree->child[0]=yyattribute(1 - 4).ptree; 
               yyval.ptree->child[1]=yyattribute(4 - 4).ptree; 
               yyval.ptree->lineno = savedLineno; 
               
#line 752 "parse.c" 
			} 
		} 
		break; 
	case 38: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 247 ".\\parse.y" 
yyval.ptree = yyattribute(1 - 1).ptree; 
#line 765 "parse.c" 
			} 
		} 
		break; 
	case 39: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 248 ".\\parse.y" 
yyval.ptree = yyattribute(1 - 1).ptree; 
#line 778 "parse.c" 
			} 
		} 
		break; 
	case 40: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[7]; 
			yyinitdebug(yya, 7); 
#endif 
			{ 
#line 250 ".\\parse.y" 
yyval.ptree = newStmtNode(IfK); 
               yyval.ptree->child[0] = yyattribute(2 - 6).ptree; 
               yyval.ptree->child[1] = yyattribute(4 - 6).ptree; 
               yyval.ptree->child[2] = yyattribute(6 - 6).ptree; 
               
#line 795 "parse.c" 
			} 
		} 
		break; 
	case 41: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[5]; 
			yyinitdebug(yya, 5); 
#endif 
			{ 
#line 256 ".\\parse.y" 
yyval.ptree = newStmtNode(WhileK); 
               yyval.ptree->child[0]=yyattribute(2 - 4).ptree; 
               yyval.ptree->child[1]=yyattribute(4 - 4).ptree;  
               
#line 811 "parse.c" 
			} 
		} 
		break; 
	case 42: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 261 ".\\parse.y" 
yyval.ptree=newExpNode(IdK); 
               yyval.ptree->name=copyString(tokenString); 
               
#line 826 "parse.c" 
			} 
		} 
		break; 
	case 43: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 264 ".\\parse.y" 
savedName=copyString(tokenString); 
#line 839 "parse.c" 
			} 
		} 
		break; 
	case 44: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 266 ".\\parse.y" 
yyval.ptree=newExpNode(IdK); 
              yyval.ptree->name=savedName; 
              yyval.ptree->type=Array; 
              yyval.ptree->child[0]=yyattribute(4 - 5).ptree; 
              
#line 856 "parse.c" 
			} 
		} 
		break; 
	case 45: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 272 ".\\parse.y" 
yyval.ptree = newStmtNode(CallK); 
                         yyval.ptree->name=copyString(tokenString); 
                         
#line 871 "parse.c" 
			} 
		} 
		break; 
	case 46: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 275 ".\\parse.y" 
pushName(copyString(tokenString)); 
#line 884 "parse.c" 
			} 
		} 
		break; 
	case 47: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 277 ".\\parse.y" 
yyval.ptree = newStmtNode(CallK); 
                         yyval.ptree->name=popName(); 
                         yyval.ptree->child[0] = yyattribute(4 - 5).ptree; 
                         
#line 900 "parse.c" 
			} 
		} 
		break; 
	case 48: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 282 ".\\parse.y" 
yyval.ptree = yyattribute(1 - 1).ptree; 
#line 913 "parse.c" 
			} 
		} 
		break; 
	case 49: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 284 ".\\parse.y" 
 TreeNode * t = yyattribute(1 - 3).ptree; 
                    if (t != NULL){ 
                      while (t->sibling != NULL) 
                        t = t->sibling; 
                      t->sibling = yyattribute(3 - 3).ptree; 
                      yyval.ptree = yyattribute(1 - 3).ptree; } 
                    else yyval.ptree = yyattribute(3 - 3).ptree; 
                   
#line 933 "parse.c" 
			} 
		} 
		break; 
	case 50: 
		{ 
#line 292 ".\\parse.y" 
yyval.ptree=NULL; 
#line 941 "parse.c" 
		} 
		break; 
	case 51: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 294 ".\\parse.y" 
yyval.ptree = yyattribute(1 - 1).ptree; 
#line 953 "parse.c" 
			} 
		} 
		break; 
	case 52: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 296 ".\\parse.y" 
yyval.ptree=newExpNode(OpK); 
					yyval.ptree->child[0]=yyattribute(1 - 3).ptree; 
					yyval.ptree->child[1]=yyattribute(3 - 3).ptree; 
					yyval.ptree->attr.op=yyattribute(2 - 3).tt; 
				 
#line 970 "parse.c" 
			} 
		} 
		break; 
	case 53: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 302 ".\\parse.y" 
yyval.ptree=yyattribute(1 - 1).ptree; 
#line 983 "parse.c" 
			} 
		} 
		break; 
	case 54: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 304 ".\\parse.y" 
yyval.ptree=newExpNode(OpK); 
                     yyval.ptree->child[0]=yyattribute(1 - 3).ptree; 
                     yyval.ptree->child[1]=yyattribute(3 - 3).ptree; 
                     yyval.ptree->attr.op=yyattribute(2 - 3).tt; 
                     
#line 1000 "parse.c" 
			} 
		} 
		break; 
	case 55: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 310 ".\\parse.y" 
yyval.ptree=yyattribute(1 - 1).ptree; 
#line 1013 "parse.c" 
			} 
		} 
		break; 
	case 56: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 312 ".\\parse.y" 
yyval.ptree=newExpNode(SignK); 
		 yyval.ptree->child[0]=yyattribute(2 - 2).ptree; 
		 yyval.ptree->attr.op=yyattribute(1 - 2).tt; 
		 
#line 1029 "parse.c" 
			} 
		} 
		break; 
	case 57: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 317 ".\\parse.y" 
yyval.ptree=newExpNode(OpK); 
         yyval.ptree->child[0]=yyattribute(1 - 3).ptree; 
         yyval.ptree->child[1]=yyattribute(3 - 3).ptree; 
         yyval.ptree->attr.op=yyattribute(2 - 3).tt; 
         
#line 1046 "parse.c" 
			} 
		} 
		break; 
	case 58: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 323 ".\\parse.y" 
yyval.ptree=newExpNode(IdK); 
             yyval.ptree->name=copyString(tokenString); 
             
#line 1061 "parse.c" 
			} 
		} 
		break; 
	case 59: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 326 ".\\parse.y" 
pushName(copyString(tokenString)); 
#line 1074 "parse.c" 
			} 
		} 
		break; 
	case 60: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 328 ".\\parse.y" 
yyval.ptree=newStmtNode(CallK); 
             yyval.ptree->name=popName(); 
             yyval.ptree->child[0]=yyattribute(4 - 5).ptree;  
             
#line 1090 "parse.c" 
			} 
		} 
		break; 
	case 61: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 332 ".\\parse.y" 
pushName(copyString(tokenString)); 
#line 1103 "parse.c" 
			} 
		} 
		break; 
	case 62: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[6]; 
			yyinitdebug(yya, 6); 
#endif 
			{ 
#line 334 ".\\parse.y" 
yyval.ptree=newExpNode(IdK); 
             yyval.ptree->type = Array;  
             yyval.ptree->name=popName(); 
             yyval.ptree->child[0]=yyattribute(4 - 5).ptree;    
             
#line 1120 "parse.c" 
			} 
		} 
		break; 
	case 63: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 340 ".\\parse.y" 
yyval.ptree=newExpNode(NumK); 
           yyval.ptree->type = Integer; 
           yyval.ptree->attr.intval=atoi(tokenString); 
           
#line 1136 "parse.c" 
			} 
		} 
		break; 
	case 64: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 345 ".\\parse.y" 
yyval.ptree=newExpNode(RealNumK); 
           yyval.ptree->type = Real; 
           yyval.ptree->attr.realval=atof(tokenString); 
           
#line 1152 "parse.c" 
			} 
		} 
		break; 
	case 65: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 349 ".\\parse.y" 
yyval.ptree=newExpNode(BoolK); 
				   yyval.ptree->type = Boolean;	 
				   yyval.ptree->attr.intval=1; 
#line 1167 "parse.c" 
			} 
		} 
		break; 
	case 66: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 352 ".\\parse.y" 
yyval.ptree=newExpNode(BoolK); 
				   yyval.ptree->type = Boolean;	 
				   yyval.ptree->attr.intval=0; 
#line 1182 "parse.c" 
			} 
		} 
		break; 
	case 67: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[4]; 
			yyinitdebug(yya, 4); 
#endif 
			{ 
#line 355 ".\\parse.y" 
yyval.ptree=yyattribute(2 - 3).ptree; 
#line 1195 "parse.c" 
			} 
		} 
		break; 
	case 68: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[3]; 
			yyinitdebug(yya, 3); 
#endif 
			{ 
#line 357 ".\\parse.y" 
yyval.ptree=newExpNode(OpK); 
		  yyval.ptree->child[0]=yyattribute(2 - 2).ptree; 
		  yyval.ptree->attr.op=NOT; 
		  
#line 1211 "parse.c" 
			} 
		} 
		break; 
	case 69: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 362 ".\\parse.y" 
yyval.tt=EQ; 
#line 1224 "parse.c" 
			} 
		} 
		break; 
	case 70: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 363 ".\\parse.y" 
yyval.tt=NE; 
#line 1237 "parse.c" 
			} 
		} 
		break; 
	case 71: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 364 ".\\parse.y" 
yyval.tt=LT; 
#line 1250 "parse.c" 
			} 
		} 
		break; 
	case 72: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 365 ".\\parse.y" 
yyval.tt=LE; 
#line 1263 "parse.c" 
			} 
		} 
		break; 
	case 73: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 366 ".\\parse.y" 
yyval.tt=GT; 
#line 1276 "parse.c" 
			} 
		} 
		break; 
	case 74: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 367 ".\\parse.y" 
yyval.tt=GE; 
#line 1289 "parse.c" 
			} 
		} 
		break; 
	case 75: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 369 ".\\parse.y" 
yyval.tt=PLUS; 
#line 1302 "parse.c" 
			} 
		} 
		break; 
	case 76: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 370 ".\\parse.y" 
yyval.tt=MINUS; 
#line 1315 "parse.c" 
			} 
		} 
		break; 
	case 77: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 371 ".\\parse.y" 
yyval.tt=OR; 
#line 1328 "parse.c" 
			} 
		} 
		break; 
	case 78: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 373 ".\\parse.y" 
yyval.tt=TIMES; 
#line 1341 "parse.c" 
			} 
		} 
		break; 
	case 79: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 374 ".\\parse.y" 
yyval.tt=OVER; 
#line 1354 "parse.c" 
			} 
		} 
		break; 
	case 80: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 375 ".\\parse.y" 
yyval.tt=DIV; 
#line 1367 "parse.c" 
			} 
		} 
		break; 
	case 81: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 376 ".\\parse.y" 
yyval.tt=MOD; 
#line 1380 "parse.c" 
			} 
		} 
		break; 
	case 82: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 377 ".\\parse.y" 
yyval.tt=AND; 
#line 1393 "parse.c" 
			} 
		} 
		break; 
	case 83: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 379 ".\\parse.y" 
yyval.tt=PLUS; 
#line 1406 "parse.c" 
			} 
		} 
		break; 
	case 84: 
		{ 
#ifdef YYDEBUG 
			YYSTYPE YYFAR *yya[2]; 
			yyinitdebug(yya, 2); 
#endif 
			{ 
#line 380 ".\\parse.y" 
yyval.tt=MINUS; 
#line 1419 "parse.c" 
			} 
		} 
		break; 
	default: 
		yyassert(0); 
		break; 
	} 
} 
#ifdef YYDEBUG 
YYCONST yysymbol_t YYNEARFAR YYBASED_CODE YYDCDECL yysymbol[] = { 
	{ "$end", 0 }, 
	{ "error", 256 }, 
	{ "AND", 257 }, 
	{ "ARRAY", 258 }, 
	{ "BOOLEAN", 259 }, 
	{ "DO", 260 }, 
	{ "ELSE", 261 }, 
	{ "END", 262 }, 
	{ "MYFALSE", 263 }, 
	{ "FUNCTION", 264 }, 
	{ "IF", 265 }, 
	{ "INTEGER", 266 }, 
	{ "MYBEGIN", 267 }, 
	{ "NOT", 268 }, 
	{ "OF", 269 }, 
	{ "OR", 270 }, 
	{ "PROCEDURE", 271 }, 
	{ "PROGRAM", 272 }, 
	{ "REAL", 273 }, 
	{ "THEN", 274 }, 
	{ "MYTRUE", 275 }, 
	{ "VAR", 276 }, 
	{ "WHILE", 277 }, 
	{ "ID", 278 }, 
	{ "NUM", 279 }, 
	{ "REALNUM", 280 }, 
	{ "ASSIGNOP", 281 }, 
	{ "DOT", 282 }, 
	{ "SEMI", 283 }, 
	{ "COLON", 284 }, 
	{ "COMMA", 285 }, 
	{ "LSP", 286 }, 
	{ "RSP", 287 }, 
	{ "LP", 288 }, 
	{ "RP", 289 }, 
	{ "EQ", 290 }, 
	{ "NE", 291 }, 
	{ "LT", 292 }, 
	{ "LE", 293 }, 
	{ "GT", 294 }, 
	{ "GE", 295 }, 
	{ "PLUS", 296 }, 
	{ "MINUS", 297 }, 
	{ "TIMES", 298 }, 
	{ "OVER", 299 }, 
	{ "DIV", 300 }, 
	{ "MOD", 301 }, 
	{ NULL, 0 } 
}; 
 
YYCONST char *YYCONST YYNEARFAR YYBASED_CODE YYDCDECL yyrule[] = { 
	"$accept: program", 
	"$$1:", 
	"program: PROGRAM ID $$1 LP identifier_list RP SEMI declarations subprogram_declarations compound_statement", 
	"identifier_list: ID", 
	"identifier_list: identifier_list COMMA id", 
	"id: ID", 
	"declarations: VAR declaration SEMI", 
	"declarations:", 
	"declaration: declaration SEMI identifier_list COLON type", 
	"declaration: identifier_list COLON type", 
	"type: standard_type", 
	"$$2:", 
	"$$3:", 
	"type: ARRAY LSP NUM $$2 DOT DOT NUM $$3 RSP OF standard_type", 
	"standard_type: INTEGER", 
	"standard_type: REAL", 
	"standard_type: BOOLEAN", 
	"subprogram_declarations: subprogram_declarations subprogram_declaration SEMI", 
	"subprogram_declarations:", 
	"subprogram_declaration: subprogram_head declarations compound_statement", 
	"$$4:", 
	"subprogram_head: FUNCTION ID $$4 arguments COLON standard_type SEMI", 
	"$$5:", 
	"subprogram_head: PROCEDURE ID $$5 arguments SEMI", 
	"arguments: LP parameter_list RP", 
	"arguments:", 
	"parameter_list: identifier_list COLON type", 
	"parameter_list: parameter_list SEMI identifier_list COLON type", 
	"parameter_list: VAR identifier_list COLON type", 
	"parameter_list: parameter_list SEMI VAR identifier_list COLON type", 
	"parameter_list:", 
	"compound_statement: MYBEGIN optional_statements END", 
	"optional_statements: statement_list SEMI", 
	"optional_statements: statement_list", 
	"optional_statements:", 
	"statement_list: statement", 
	"statement_list: statement_list SEMI statement", 
	"$$6:", 
	"statement: variable ASSIGNOP $$6 expression", 
	"statement: procedure_statement", 
	"statement: compound_statement", 
	"statement: IF expression THEN statement ELSE statement", 
	"statement: WHILE expression DO statement", 
	"variable: ID", 
	"$$7:", 
	"variable: ID $$7 LSP expression RSP", 
	"procedure_statement: ID", 
	"$$8:", 
	"procedure_statement: ID $$8 LP expression_list RP", 
	"expression_list: expression", 
	"expression_list: expression_list COMMA expression", 
	"expression_list:", 
	"expression: simple_expression", 
	"expression: simple_expression relop simple_expression", 
	"simple_expression: term", 
	"simple_expression: simple_expression addop term", 
	"term: factor", 
	"term: sign factor", 
	"term: term mulop factor", 
	"factor: ID", 
	"$$9:", 
	"factor: ID $$9 LP expression_list RP", 
	"$$10:", 
	"factor: ID $$10 LSP expression RSP", 
	"factor: NUM", 
	"factor: REALNUM", 
	"factor: MYTRUE", 
	"factor: MYFALSE", 
	"factor: LP expression RP", 
	"factor: NOT factor", 
	"relop: EQ", 
	"relop: NE", 
	"relop: LT", 
	"relop: LE", 
	"relop: GT", 
	"relop: GE", 
	"addop: PLUS", 
	"addop: MINUS", 
	"addop: OR", 
	"mulop: TIMES", 
	"mulop: OVER", 
	"mulop: DIV", 
	"mulop: MOD", 
	"mulop: AND", 
	"sign: PLUS", 
	"sign: MINUS" 
}; 
#endif 
 
YYCONST yyreduction_t YYNEARFAR YYBASED_CODE YYDCDECL yyreduction[] = { 
	{ 0, 1, -1 }, 
	{ 2, 0, 0 }, 
	{ 1, 10, 1 }, 
	{ 3, 1, 2 }, 
	{ 3, 3, 3 }, 
	{ 4, 1, 4 }, 
	{ 5, 3, 5 }, 
	{ 5, 0, 6 }, 
	{ 6, 5, 7 }, 
	{ 6, 3, 8 }, 
	{ 7, 1, 9 }, 
	{ 8, 0, 10 }, 
	{ 9, 0, 11 }, 
	{ 7, 11, 12 }, 
	{ 10, 1, 13 }, 
	{ 10, 1, 14 }, 
	{ 10, 1, 15 }, 
	{ 11, 3, 16 }, 
	{ 11, 0, 17 }, 
	{ 12, 3, 18 }, 
	{ 14, 0, 19 }, 
	{ 13, 7, 20 }, 
	{ 15, 0, 21 }, 
	{ 13, 5, 22 }, 
	{ 16, 3, 23 }, 
	{ 16, 0, 24 }, 
	{ 17, 3, 25 }, 
	{ 17, 5, 26 }, 
	{ 17, 4, 27 }, 
	{ 17, 6, 28 }, 
	{ 17, 0, 29 }, 
	{ 18, 3, 30 }, 
	{ 19, 2, 31 }, 
	{ 19, 1, 32 }, 
	{ 19, 0, 33 }, 
	{ 20, 1, 34 }, 
	{ 20, 3, 35 }, 
	{ 22, 0, 36 }, 
	{ 21, 4, 37 }, 
	{ 21, 1, 38 }, 
	{ 21, 1, 39 }, 
	{ 21, 6, 40 }, 
	{ 21, 4, 41 }, 
	{ 23, 1, 42 }, 
	{ 24, 0, 43 }, 
	{ 23, 5, 44 }, 
	{ 25, 1, 45 }, 
	{ 26, 0, 46 }, 
	{ 25, 5, 47 }, 
	{ 27, 1, 48 }, 
	{ 27, 3, 49 }, 
	{ 27, 0, 50 }, 
	{ 28, 1, 51 }, 
	{ 28, 3, 52 }, 
	{ 29, 1, 53 }, 
	{ 29, 3, 54 }, 
	{ 30, 1, 55 }, 
	{ 30, 2, 56 }, 
	{ 30, 3, 57 }, 
	{ 31, 1, 58 }, 
	{ 32, 0, 59 }, 
	{ 31, 5, 60 }, 
	{ 33, 0, 61 }, 
	{ 31, 5, 62 }, 
	{ 31, 1, 63 }, 
	{ 31, 1, 64 }, 
	{ 31, 1, 65 }, 
	{ 31, 1, 66 }, 
	{ 31, 3, 67 }, 
	{ 31, 2, 68 }, 
	{ 34, 1, 69 }, 
	{ 34, 1, 70 }, 
	{ 34, 1, 71 }, 
	{ 34, 1, 72 }, 
	{ 34, 1, 73 }, 
	{ 34, 1, 74 }, 
	{ 35, 1, 75 }, 
	{ 35, 1, 76 }, 
	{ 35, 1, 77 }, 
	{ 36, 1, 78 }, 
	{ 36, 1, 79 }, 
	{ 36, 1, 80 }, 
	{ 36, 1, 81 }, 
	{ 36, 1, 82 }, 
	{ 37, 1, 83 }, 
	{ 37, 1, 84 } 
}; 
 
int YYNEAR YYDCDECL yytokenaction_size = 130; 
YYCONST yytokenaction_t YYNEARFAR YYBASED_CODE YYDCDECL yytokenaction[] = { 
	{ 132, YYAT_SHIFT, 49 }, 
	{ 113, YYAT_SHIFT, 80 }, 
	{ 73, YYAT_SHIFT, 105 }, 
	{ 17, YYAT_SHIFT, 20 }, 
	{ 73, YYAT_SHIFT, 6 }, 
	{ 132, YYAT_SHIFT, 50 }, 
	{ 109, YYAT_SHIFT, 49 }, 
	{ 67, YYAT_SHIFT, 34 }, 
	{ 114, YYAT_SHIFT, 91 }, 
	{ 67, YYAT_SHIFT, 21 }, 
	{ 17, YYAT_SHIFT, 22 }, 
	{ 109, YYAT_SHIFT, 50 }, 
	{ 132, YYAT_SHIFT, 51 }, 
	{ 146, YYAT_SHIFT, 149 }, 
	{ 146, YYAT_SHIFT, 8 }, 
	{ 132, YYAT_SHIFT, 52 }, 
	{ 132, YYAT_SHIFT, 53 }, 
	{ 132, YYAT_SHIFT, 54 }, 
	{ 109, YYAT_SHIFT, 51 }, 
	{ 67, YYAT_SHIFT, 35 }, 
	{ 67, YYAT_SHIFT, 36 }, 
	{ 109, YYAT_SHIFT, 52 }, 
	{ 109, YYAT_SHIFT, 53 }, 
	{ 109, YYAT_SHIFT, 54 }, 
	{ 151, YYAT_SHIFT, 153 }, 
	{ 132, YYAT_SHIFT, 55 }, 
	{ 107, YYAT_SHIFT, 125 }, 
	{ 113, YYAT_SHIFT, 87 }, 
	{ 113, YYAT_SHIFT, 88 }, 
	{ 149, YYAT_SHIFT, 26 }, 
	{ 100, YYAT_SHIFT, 49 }, 
	{ 109, YYAT_SHIFT, 55 }, 
	{ 107, YYAT_SHIFT, 126 }, 
	{ 132, YYAT_SHIFT, 56 }, 
	{ 132, YYAT_SHIFT, 57 }, 
	{ 100, YYAT_SHIFT, 50 }, 
	{ 60, YYAT_SHIFT, 91 }, 
	{ 96, YYAT_ERROR, 0 }, 
	{ 96, YYAT_ERROR, 0 }, 
	{ 109, YYAT_SHIFT, 56 }, 
	{ 109, YYAT_SHIFT, 57 }, 
	{ 21, YYAT_SHIFT, 34 }, 
	{ 100, YYAT_SHIFT, 51 }, 
	{ 21, YYAT_SHIFT, 21 }, 
	{ 130, YYAT_SHIFT, 34 }, 
	{ 100, YYAT_SHIFT, 52 }, 
	{ 100, YYAT_SHIFT, 53 }, 
	{ 100, YYAT_SHIFT, 54 }, 
	{ 59, YYAT_SHIFT, 80 }, 
	{ 114, YYAT_SHIFT, 92 }, 
	{ 114, YYAT_SHIFT, 93 }, 
	{ 114, YYAT_SHIFT, 94 }, 
	{ 114, YYAT_SHIFT, 95 }, 
	{ 21, YYAT_SHIFT, 35 }, 
	{ 21, YYAT_SHIFT, 36 }, 
	{ 100, YYAT_SHIFT, 55 }, 
	{ 130, YYAT_SHIFT, 35 }, 
	{ 130, YYAT_SHIFT, 36 }, 
	{ 128, YYAT_SHIFT, 132 }, 
	{ 52, YYAT_REDUCE, 62 }, 
	{ 36, YYAT_REDUCE, 43 }, 
	{ 52, YYAT_REDUCE, 60 }, 
	{ 128, YYAT_SHIFT, 140 }, 
	{ 100, YYAT_SHIFT, 56 }, 
	{ 100, YYAT_SHIFT, 57 }, 
	{ 36, YYAT_REDUCE, 44 }, 
	{ 148, YYAT_SHIFT, 151 }, 
	{ 36, YYAT_REDUCE, 47 }, 
	{ 59, YYAT_SHIFT, 81 }, 
	{ 59, YYAT_SHIFT, 82 }, 
	{ 59, YYAT_SHIFT, 83 }, 
	{ 59, YYAT_SHIFT, 84 }, 
	{ 59, YYAT_SHIFT, 85 }, 
	{ 59, YYAT_SHIFT, 86 }, 
	{ 59, YYAT_SHIFT, 87 }, 
	{ 59, YYAT_SHIFT, 88 }, 
	{ 153, YYAT_SHIFT, 27 }, 
	{ 60, YYAT_SHIFT, 92 }, 
	{ 60, YYAT_SHIFT, 93 }, 
	{ 60, YYAT_SHIFT, 94 }, 
	{ 60, YYAT_SHIFT, 95 }, 
	{ 7, YYAT_SHIFT, 8 }, 
	{ 138, YYAT_SHIFT, 147 }, 
	{ 153, YYAT_SHIFT, 28 }, 
	{ 137, YYAT_SHIFT, 6 }, 
	{ 7, YYAT_SHIFT, 9 }, 
	{ 134, YYAT_SHIFT, 144 }, 
	{ 129, YYAT_SHIFT, 141 }, 
	{ 127, YYAT_SHIFT, 139 }, 
	{ 125, YYAT_SHIFT, 137 }, 
	{ 153, YYAT_SHIFT, 29 }, 
	{ 123, YYAT_SHIFT, 135 }, 
	{ 122, YYAT_SHIFT, 134 }, 
	{ 118, YYAT_SHIFT, 133 }, 
	{ 117, YYAT_SHIFT, 131 }, 
	{ 112, YYAT_SHIFT, 130 }, 
	{ 106, YYAT_SHIFT, 124 }, 
	{ 104, YYAT_SHIFT, 122 }, 
	{ 103, YYAT_SHIFT, 121 }, 
	{ 78, YYAT_SHIFT, 111 }, 
	{ 77, YYAT_SHIFT, 110 }, 
	{ 76, YYAT_SHIFT, 109 }, 
	{ 74, YYAT_SHIFT, 108 }, 
	{ 69, YYAT_SHIFT, 73 }, 
	{ 65, YYAT_SHIFT, 100 }, 
	{ 64, YYAT_SHIFT, 99 }, 
	{ 63, YYAT_SHIFT, 98 }, 
	{ 58, YYAT_SHIFT, 79 }, 
	{ 48, YYAT_SHIFT, 73 }, 
	{ 46, YYAT_SHIFT, 71 }, 
	{ 45, YYAT_SHIFT, 21 }, 
	{ 41, YYAT_SHIFT, 68 }, 
	{ 39, YYAT_SHIFT, 67 }, 
	{ 38, YYAT_SHIFT, 66 }, 
	{ 32, YYAT_SHIFT, 47 }, 
	{ 26, YYAT_SHIFT, 46 }, 
	{ 24, YYAT_SHIFT, 13 }, 
	{ 23, YYAT_SHIFT, 44 }, 
	{ 22, YYAT_SHIFT, 43 }, 
	{ 20, YYAT_SHIFT, 33 }, 
	{ 19, YYAT_SHIFT, 6 }, 
	{ 16, YYAT_SHIFT, 19 }, 
	{ 15, YYAT_SHIFT, 18 }, 
	{ 12, YYAT_SHIFT, 13 }, 
	{ 9, YYAT_SHIFT, 12 }, 
	{ 8, YYAT_SHIFT, 10 }, 
	{ 4, YYAT_SHIFT, 5 }, 
	{ 2, YYAT_ACCEPT, 0 }, 
	{ 1, YYAT_SHIFT, 3 }, 
	{ 0, YYAT_SHIFT, 1 } 
}; 
 
YYCONST yystateaction_t YYNEARFAR YYBASED_CODE YYDCDECL yystateaction[] = { 
	{ -143, 1, YYAT_ERROR, 0 }, 
	{ -150, 1, YYAT_ERROR, 0 }, 
	{ 127, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 1 }, 
	{ -162, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 137 }, 
	{ 0, 0, YYAT_REDUCE, 3 }, 
	{ -204, 1, YYAT_ERROR, 0 }, 
	{ -153, 1, YYAT_ERROR, 0 }, 
	{ -159, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 5 }, 
	{ 0, 0, YYAT_REDUCE, 4 }, 
	{ -153, 1, YYAT_REDUCE, 7 }, 
	{ 0, 0, YYAT_DEFAULT, 137 }, 
	{ 0, 0, YYAT_REDUCE, 18 }, 
	{ -162, 1, YYAT_DEFAULT, 146 }, 
	{ -162, 1, YYAT_ERROR, 0 }, 
	{ -261, 1, YYAT_DEFAULT, 45 }, 
	{ 0, 0, YYAT_DEFAULT, 149 }, 
	{ -158, 1, YYAT_REDUCE, 6 }, 
	{ -159, 1, YYAT_ERROR, 0 }, 
	{ -224, 1, YYAT_REDUCE, 34 }, 
	{ -160, 1, YYAT_ERROR, 0 }, 
	{ -166, 1, YYAT_ERROR, 0 }, 
	{ -160, 1, YYAT_REDUCE, 7 }, 
	{ 0, 0, YYAT_REDUCE, 2 }, 
	{ -171, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 16 }, 
	{ 0, 0, YYAT_REDUCE, 14 }, 
	{ 0, 0, YYAT_REDUCE, 15 }, 
	{ 0, 0, YYAT_REDUCE, 9 }, 
	{ 0, 0, YYAT_REDUCE, 10 }, 
	{ -170, 1, YYAT_DEFAULT, 146 }, 
	{ 0, 0, YYAT_REDUCE, 20 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ -221, 1, YYAT_REDUCE, 46 }, 
	{ 0, 0, YYAT_REDUCE, 40 }, 
	{ -149, 1, YYAT_ERROR, 0 }, 
	{ -171, 1, YYAT_REDUCE, 33 }, 
	{ 0, 0, YYAT_REDUCE, 35 }, 
	{ -170, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 39 }, 
	{ 0, 0, YYAT_REDUCE, 22 }, 
	{ 0, 0, YYAT_REDUCE, 17 }, 
	{ -157, 1, YYAT_ERROR, 0 }, 
	{ -170, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 149 }, 
	{ -180, 1, YYAT_REDUCE, 25 }, 
	{ 0, 0, YYAT_REDUCE, 67 }, 
	{ 0, 0, YYAT_DEFAULT, 96 }, 
	{ 0, 0, YYAT_REDUCE, 66 }, 
	{ -227, 1, YYAT_REDUCE, 59 }, 
	{ 0, 0, YYAT_REDUCE, 64 }, 
	{ 0, 0, YYAT_REDUCE, 65 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ 0, 0, YYAT_REDUCE, 84 }, 
	{ 0, 0, YYAT_REDUCE, 85 }, 
	{ -167, 1, YYAT_ERROR, 0 }, 
	{ -222, 1, YYAT_REDUCE, 52 }, 
	{ -221, 1, YYAT_REDUCE, 54 }, 
	{ 0, 0, YYAT_REDUCE, 56 }, 
	{ 0, 0, YYAT_DEFAULT, 96 }, 
	{ -154, 1, YYAT_ERROR, 0 }, 
	{ -181, 1, YYAT_ERROR, 0 }, 
	{ -184, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 31 }, 
	{ -258, 1, YYAT_REDUCE, 32 }, 
	{ 0, 0, YYAT_REDUCE, 37 }, 
	{ -185, 1, YYAT_REDUCE, 25 }, 
	{ 0, 0, YYAT_REDUCE, 19 }, 
	{ 0, 0, YYAT_REDUCE, 11 }, 
	{ 0, 0, YYAT_REDUCE, 8 }, 
	{ -274, 1, YYAT_REDUCE, 30 }, 
	{ -182, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 69 }, 
	{ -187, 1, YYAT_ERROR, 0 }, 
	{ -186, 1, YYAT_ERROR, 0 }, 
	{ -190, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 130 }, 
	{ 0, 0, YYAT_REDUCE, 78 }, 
	{ 0, 0, YYAT_REDUCE, 70 }, 
	{ 0, 0, YYAT_REDUCE, 71 }, 
	{ 0, 0, YYAT_REDUCE, 72 }, 
	{ 0, 0, YYAT_REDUCE, 73 }, 
	{ 0, 0, YYAT_REDUCE, 74 }, 
	{ 0, 0, YYAT_REDUCE, 75 }, 
	{ 0, 0, YYAT_REDUCE, 76 }, 
	{ 0, 0, YYAT_REDUCE, 77 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ 0, 0, YYAT_REDUCE, 83 }, 
	{ 0, 0, YYAT_REDUCE, 79 }, 
	{ 0, 0, YYAT_REDUCE, 80 }, 
	{ 0, 0, YYAT_REDUCE, 81 }, 
	{ 0, 0, YYAT_REDUCE, 82 }, 
	{ -259, 1, YYAT_DEFAULT, 132 }, 
	{ 0, 0, YYAT_REDUCE, 57 }, 
	{ 0, 0, YYAT_DEFAULT, 130 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ -233, 1, YYAT_REDUCE, 51 }, 
	{ 0, 0, YYAT_REDUCE, 36 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ -185, 1, YYAT_ERROR, 0 }, 
	{ -185, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 137 }, 
	{ -188, 1, YYAT_DEFAULT, 146 }, 
	{ -257, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 153 }, 
	{ -257, 1, YYAT_REDUCE, 51 }, 
	{ 0, 0, YYAT_DEFAULT, 132 }, 
	{ 0, 0, YYAT_REDUCE, 68 }, 
	{ -166, 1, YYAT_ERROR, 0 }, 
	{ -269, 1, YYAT_REDUCE, 53 }, 
	{ -249, 1, YYAT_REDUCE, 55 }, 
	{ 0, 0, YYAT_REDUCE, 58 }, 
	{ 0, 0, YYAT_REDUCE, 42 }, 
	{ -193, 1, YYAT_ERROR, 0 }, 
	{ -196, 1, YYAT_DEFAULT, 128 }, 
	{ 0, 0, YYAT_REDUCE, 49 }, 
	{ 0, 0, YYAT_REDUCE, 38 }, 
	{ 0, 0, YYAT_REDUCE, 23 }, 
	{ -190, 1, YYAT_ERROR, 0 }, 
	{ -193, 1, YYAT_DEFAULT, 146 }, 
	{ 0, 0, YYAT_DEFAULT, 149 }, 
	{ -187, 1, YYAT_DEFAULT, 137 }, 
	{ 0, 0, YYAT_REDUCE, 24 }, 
	{ -195, 1, YYAT_ERROR, 0 }, 
	{ -227, 1, YYAT_ERROR, 0 }, 
	{ -200, 1, YYAT_ERROR, 0 }, 
	{ -221, 1, YYAT_DEFAULT, 45 }, 
	{ 0, 0, YYAT_REDUCE, 45 }, 
	{ -263, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 48 }, 
	{ -193, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 149 }, 
	{ 0, 0, YYAT_REDUCE, 26 }, 
	{ -194, 1, YYAT_ERROR, 0 }, 
	{ -202, 1, YYAT_DEFAULT, 146 }, 
	{ 0, 0, YYAT_REDUCE, 21 }, 
	{ 0, 0, YYAT_REDUCE, 61 }, 
	{ 0, 0, YYAT_REDUCE, 63 }, 
	{ 0, 0, YYAT_REDUCE, 41 }, 
	{ 0, 0, YYAT_REDUCE, 50 }, 
	{ 0, 0, YYAT_REDUCE, 12 }, 
	{ 0, 0, YYAT_REDUCE, 28 }, 
	{ -271, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_DEFAULT, 149 }, 
	{ -221, 1, YYAT_ERROR, 0 }, 
	{ -229, 1, YYAT_DEFAULT, 153 }, 
	{ 0, 0, YYAT_REDUCE, 27 }, 
	{ -245, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 29 }, 
	{ -183, 1, YYAT_ERROR, 0 }, 
	{ 0, 0, YYAT_REDUCE, 13 } 
}; 
 
int YYNEAR YYDCDECL yynontermgoto_size = 73; 
 
YYCONST yynontermgoto_t YYNEARFAR YYBASED_CODE YYDCDECL yynontermgoto[] = { 
	{ 132, 143 }, 
	{ 132, 59 }, 
	{ 132, 60 }, 
	{ 132, 61 }, 
	{ 73, 106 }, 
	{ 130, 37 }, 
	{ 109, 128 }, 
	{ 109, 119 }, 
	{ 130, 142 }, 
	{ 132, 62 }, 
	{ 130, 41 }, 
	{ 153, 154 }, 
	{ 130, 42 }, 
	{ 17, 23 }, 
	{ 17, 24 }, 
	{ 21, 38 }, 
	{ 21, 39 }, 
	{ 21, 40 }, 
	{ 73, 107 }, 
	{ 17, 25 }, 
	{ 149, 152 }, 
	{ 13, 15 }, 
	{ 147, 150 }, 
	{ 149, 31 }, 
	{ 13, 16 }, 
	{ 36, 64 }, 
	{ 144, 148 }, 
	{ 36, 65 }, 
	{ 90, -1 }, 
	{ 90, 114 }, 
	{ 89, -1 }, 
	{ 89, 113 }, 
	{ 52, 76 }, 
	{ 52, 77 }, 
	{ 137, 146 }, 
	{ 135, 145 }, 
	{ 125, 138 }, 
	{ 124, 136 }, 
	{ 114, 96 }, 
	{ 113, 90 }, 
	{ 110, 129 }, 
	{ 108, 127 }, 
	{ 105, 123 }, 
	{ 102, 120 }, 
	{ 100, 118 }, 
	{ 99, 117 }, 
	{ 98, 116 }, 
	{ 96, 115 }, 
	{ 79, 112 }, 
	{ 71, 104 }, 
	{ 69, 103 }, 
	{ 68, 102 }, 
	{ 67, 101 }, 
	{ 62, 97 }, 
	{ 59, 89 }, 
	{ 55, 78 }, 
	{ 50, 75 }, 
	{ 48, 74 }, 
	{ 47, 72 }, 
	{ 45, 70 }, 
	{ 43, 69 }, 
	{ 35, 63 }, 
	{ 34, 58 }, 
	{ 33, 48 }, 
	{ 24, 45 }, 
	{ 19, 32 }, 
	{ 18, 30 }, 
	{ 14, 17 }, 
	{ 12, 14 }, 
	{ 8, 11 }, 
	{ 5, 7 }, 
	{ 3, 4 }, 
	{ 0, 2 } 
}; 
 
YYCONST yystategoto_t YYNEARFAR YYBASED_CODE YYDCDECL yystategoto[] = { 
	{ 71, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 69, -1 }, 
	{ 0, -1 }, 
	{ 67, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 65, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 63, -1 }, 
	{ 18, -1 }, 
	{ 56, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 1, -1 }, 
	{ 59, 149 }, 
	{ 62, -1 }, 
	{ 0, -1 }, 
	{ -4, 130 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 59, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 49, -1 }, 
	{ 34, 132 }, 
	{ 33, 132 }, 
	{ 1, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 45, -1 }, 
	{ 0, -1 }, 
	{ 41, -1 }, 
	{ 0, -1 }, 
	{ 51, 149 }, 
	{ 41, -1 }, 
	{ 0, -1 }, 
	{ 25, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 27, 132 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 20, 113 }, 
	{ 0, 114 }, 
	{ 0, -1 }, 
	{ 22, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 31, 130 }, 
	{ 29, -1 }, 
	{ 34, -1 }, 
	{ 0, -1 }, 
	{ 41, -1 }, 
	{ 0, -1 }, 
	{ 1, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 27, 130 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 2, 132 }, 
	{ -1, 89 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 16, -1 }, 
	{ 0, -1 }, 
	{ 25, 130 }, 
	{ 17, 132 }, 
	{ 17, 109 }, 
	{ 0, -1 }, 
	{ 15, 132 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 39, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 31, -1 }, 
	{ -21, 132 }, 
	{ 12, 132 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 4, -1 }, 
	{ 2, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 30, 149 }, 
	{ 33, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ -13, -1 }, 
	{ 0, -1 }, 
	{ -28, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 28, 149 }, 
	{ 0, -1 }, 
	{ 31, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 17, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 15, 149 }, 
	{ 0, -1 }, 
	{ 13, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 0, -1 }, 
	{ 1, -1 }, 
	{ 0, -1 } 
}; 
 
YYCONST yydestructor_t YYNEARFAR *YYNEAR YYDCDECL yydestructorptr = NULL; 
 
YYCONST yytokendest_t YYNEARFAR *YYNEAR YYDCDECL yytokendestptr = NULL; 
int YYNEAR YYDCDECL yytokendest_size = 0; 
 
YYCONST yytokendestbase_t YYNEARFAR *YYNEAR YYDCDECL yytokendestbaseptr = NULL; 
int YYNEAR YYDCDECL yytokendestbase_size = 0; 
#line 382 ".\\parse.y" 
 
 
void yyerror(const char * message) 
{ printf("error:(line %d) %s. (Current token:%s)\n",lineno,message,tokenString); 
  Error = TRUE; 
} 
 
/* yylex calls getToken to make Yacc/Bison output 
 * compatible with ealier versions of the TINY scanner 
 */ 
#ifdef YYPROTOTYPE 
int YYCDECL yygettoken(void) 
#else 
int YYCDECL yygettoken() 
#endif 
{ 
	return yylex(); 
} 
 
static TokenType yylex(void) 
{ return getToken(); } 
 
TreeNode * parse(void) 
{ yyparse(); 
  return savedTree; 
}