0,   103,     0,    27,    73,    75,   104,   105,   109,   113,      92,   131,   131,   131,   106,   110,   114,    93,    93,    93,       1,   107,     1,   111,     1,   115,     3,    28,    74,    79,      80,    81,    82,    83,    87,    94,    96,   108,   120,   122,     123,    94,    96,   112,   121,   122,     1,    94,    98,   116,     125,   126,   131,     1,     7,     8,     9,    10,    11,    12,      13,    14,    15,    16,    17,    18,    19,    20,    21,    22,      23,    24,    25,    26,   124,     1,     4,     6,    54,    71,      76,    77,    78,    86,    88,    90,   118,   119,    96,   123,      72,   118,    96,   131,    99,   127,    97,     1,    29,    30,      31,    32,    33,    34,    35,    36,    37,    38,    39,    40,      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,      51,    52,    53,    56,    57,    58,    59,    60,    61,    62,      63,    64,    65,    66,    67,    95,   100,   128,   124,    97,     128,    72,   131,   117,   121,     5,    55,    71,    84,    85,      86,    89,    90,    91,   101,   129,   130,   129,   131,   129,     131,   129,   129,   129,   129,   129,   129,   131,   119,   131,      97,    92,    97,   128,   131,    92};#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)# define YYSIZE_T __SIZE_TYPE__#endif#if ! defined (YYSIZE_T) && defined (size_t)# define YYSIZE_T size_t#endif#if ! defined (YYSIZE_T)# if defined (__STDC__) || defined (__cplusplus)#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */#  define YYSIZE_T size_t# endif#endif#if ! defined (YYSIZE_T)# define YYSIZE_T unsigned int#endif#define yyerrok		(yyerrstatus = 0)#define yyclearin	(yychar = YYEMPTY)#define YYEMPTY		(-2)#define YYEOF		0#define YYACCEPT	goto yyacceptlab#define YYABORT		goto yyabortlab#define YYERROR		goto yyerrlab1/* Like YYERROR except do call yyerror.  This remains here temporarily   to ease the transition to the new meaning of YYERROR, for GCC.   Once GCC version 2 has supplanted version 1, this can go.  */#define YYFAIL		goto yyerrlab#define YYRECOVERING()  (!!yyerrstatus)#define YYBACKUP(Token, Value)					\do								\  if (yychar == YYEMPTY && yylen == 1)				\    {								\      yychar = (Token);						\      yylval = (Value);						\      yytoken = YYTRANSLATE (yychar);				\      YYPOPSTACK;						\      goto yybackup;						\    }								\  else								\    { 								\      yyerror ("syntax error: cannot back up");\      YYERROR;							\    }								\while (0)#define YYTERROR	1#define YYERRCODE	256/* YYLLOC_DEFAULT -- Compute the default location (before the actions   are run).  */#ifndef YYLLOC_DEFAULT# define YYLLOC_DEFAULT(Current, Rhs, N)         \  Current.first_line   = Rhs[1].first_line;      \  Current.first_column = Rhs[1].first_column;    \  Current.last_line    = Rhs[N].last_line;       \  Current.last_column  = Rhs[N].last_column;#endif/* YYLEX -- calling `yylex' with the right arguments.  */#ifdef YYLEX_PARAM# define YYLEX yylex (YYLEX_PARAM)#else# define YYLEX yylex ()#endif/* Enable debugging if requested.  */#if YYDEBUG# ifndef YYFPRINTF#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */#  define YYFPRINTF fprintf# endif# define YYDPRINTF(Args)			\do {						\  if (yydebug)					\    YYFPRINTF Args;				\} while (0)# define YYDSYMPRINT(Args)			\do {						\  if (yydebug)					\    yysymprint Args;				\} while (0)# define YYDSYMPRINTF(Title, Token, Value, Location)		\do {								\  if (yydebug)							\    {								\      YYFPRINTF (stderr, "%s ", Title);				\      yysymprint (stderr, 					\                  Token, Value);	\      YYFPRINTF (stderr, "\n");					\    }								\} while (0)/*------------------------------------------------------------------.| yy_stack_print -- Print the state stack from its BOTTOM up to its || TOP (cinluded).                                                   |`------------------------------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyy_stack_print (short *bottom, short *top)#elsestatic voidyy_stack_print (bottom, top)    short *bottom;    short *top;#endif{  YYFPRINTF (stderr, "Stack now");  for (/* Nothing. */; bottom <= top; ++bottom)    YYFPRINTF (stderr, " %d", *bottom);  YYFPRINTF (stderr, "\n");}# define YY_STACK_PRINT(Bottom, Top)				\do {								\  if (yydebug)							\    yy_stack_print ((Bottom), (Top));				\} while (0)/*------------------------------------------------.| Report that the YYRULE is going to be reduced.  |`------------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyy_reduce_print (int yyrule)#elsestatic voidyy_reduce_print (yyrule)    int yyrule;#endif{  int yyi;  unsigned int yylineno = yyrline[yyrule];  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",             yyrule - 1, yylineno);  /* Print the symbols being reduced, and their result.  */  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);}# define YY_REDUCE_PRINT(Rule)		\do {					\  if (yydebug)				\    yy_reduce_print (Rule);		\} while (0)/* Nonzero means print parse trace.  It is left uninitialized so that   multiple parsers can coexist.  */int yydebug;#else /* !YYDEBUG */# define YYDPRINTF(Args)# define YYDSYMPRINT(Args)# define YYDSYMPRINTF(Title, Token, Value, Location)# define YY_STACK_PRINT(Bottom, Top)# define YY_REDUCE_PRINT(Rule)#endif /* !YYDEBUG *//* YYINITDEPTH -- initial size of the parser's stacks.  */#ifndef	YYINITDEPTH# define YYINITDEPTH 200#endif/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only   if the built-in stack extension method is used).   Do not make this value too large; the results are undefined if   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)   evaluated with infinite-precision integer arithmetic.  */#if YYMAXDEPTH == 0# undef YYMAXDEPTH#endif#ifndef YYMAXDEPTH# define YYMAXDEPTH 10000#endif#if YYERROR_VERBOSE# ifndef yystrlen#  if defined (__GLIBC__) && defined (_STRING_H)#   define yystrlen strlen#  else/* Return the length of YYSTR.  */static YYSIZE_T#   if defined (__STDC__) || defined (__cplusplus)yystrlen (const char *yystr)#   elseyystrlen (yystr)     const char *yystr;#   endif{  register const char *yys = yystr;  while (*yys++ != '\0')    continue;  return yys - yystr - 1;}#  endif# endif# ifndef yystpcpy#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)#   define yystpcpy stpcpy#  else/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in   YYDEST.  */static char *#   if defined (__STDC__) || defined (__cplusplus)yystpcpy (char *yydest, const char *yysrc)#   elseyystpcpy (yydest, yysrc)     char *yydest;     const char *yysrc;#   endif{  register char *yyd = yydest;  register const char *yys = yysrc;  while ((*yyd++ = *yys++) != '\0')    continue;  return yyd - 1;}#  endif# endif#endif /* !YYERROR_VERBOSE */#if YYDEBUG/*--------------------------------.| Print this symbol on YYOUTPUT.  |`--------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)#elsestatic voidyysymprint (yyoutput, yytype, yyvaluep)    FILE *yyoutput;    int yytype;    YYSTYPE *yyvaluep;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvaluep;  if (yytype < YYNTOKENS)    {      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);# ifdef YYPRINT      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);# endif    }  else    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);  switch (yytype)    {      default:        break;    }  YYFPRINTF (yyoutput, ")");}#endif /* ! YYDEBUG *//*-----------------------------------------------.| Release the memory associated to this symbol.  |`-----------------------------------------------*/#if defined (__STDC__) || defined (__cplusplus)static voidyydestruct (int yytype, YYSTYPE *yyvaluep)#elsestatic voidyydestruct (yytype, yyvaluep)    int yytype;    YYSTYPE *yyvaluep;#endif{  /* Pacify ``unused variable'' warnings.  */  (void) yyvaluep;  switch (yytype)    {      default:        break;    }}/* Prevent warnings from -Wmissing-prototypes.  */#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)int yyparse (void *YYPARSE_PARAM);# elseint yyparse ();# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)int yyparse (void);#elseint yyparse ();#endif#endif /* ! YYPARSE_PARAM *//* The lookahead symbol.  */int yychar;/* The semantic value of the lookahead symbol.  */YYSTYPE yylval;/* Number of syntax errors so far.  */int yynerrs;/*----------.| yyparse.  |`----------*/#ifdef YYPARSE_PARAM# if defined (__STDC__) || defined (__cplusplus)int yyparse (void *YYPARSE_PARAM)# elseint yyparse (YYPARSE_PARAM)  void *YYPARSE_PARAM;# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)intyyparse (void)#elseintyyparse ()#endif#endif{    register int yystate;  register int yyn;  int yyresult;  /* Number of tokens to shift before error messages enabled.  */  int yyerrstatus;  /* Lookahead token as an internal (translated) token number.  */  int yytoken = 0;  /* Three stacks and their tools:     `yyss': related to states,     `yyvs': related to semantic values,     `yyls': related to locations.     Refer to the stacks thru separate pointers, to allow yyoverflow     to reallocate them elsewhere.  */  /* The state stack.  */  short	yyssa[YYINITDEPTH];  short *yyss = yyssa;  register short *yyssp;  /* The semantic value stack.  */  YYSTYPE yyvsa[YYINITDEPTH];  YYSTYPE *yyvs = yyvsa;  register YYSTYPE *yyvsp;#define YYPOPSTACK   (yyvsp--, yyssp--)  YYSIZE_T yystacksize = YYINITDEPTH;  /* The variables used to return semantic value and location from the     action routines.  */  YYSTYPE yyval;  /* When reducing, the number of symbols on the RHS of the reduced     rule.  */  int yylen;  YYDPRINTF ((stderr, "Starting parse\n"));