TDC__) || defined (__cplusplus)
#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL
# else
#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
# endif
#else /* !YYPARSE_PARAM */
# define YYPARSE_PARAM_ARG
# define YYPARSE_PARAM_DECL
#endif /* !YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes.  */
#ifdef __GNUC__
# ifdef YYPARSE_PARAM
int yyparse (void *);
# else
int yyparse (void);
# endif
#endif


/* The lookahead symbol.  */
int yychar;

/* The semantic value of the lookahead symbol.  */
YYSTYPE yylval;

/* Number of parse errors so far.  */
int yynerrs;


int
yyparse (YYPARSE_PARAM_ARG)
     YYPARSE_PARAM_DECL
{
  
  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 yychar1 = 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"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY;		/* Cause a token to be read.  */

  /* Initialize stack pointers.
     Waste one element of value and location stack
     so that they stay on the same level as the state stack.
     The wasted elements are never initialized.  */

  yyssp = yyss;
  yyvsp = yyvs;

  goto yysetstate;

/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed. so pushing a state here evens the stacks.
     */
  yyssp++;

 yysetstate:
  *yyssp = yystate;

  if (yyssp >= yyss + yystacksize - 1)
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYSIZE_T yysize = yyssp - yyss + 1;

#ifdef yyoverflow
      {
	/* Give user a chance to reallocate the stack. Use copies of
	   these so that the &'s don't force the real ones into
	   memory.  */
	YYSTYPE *yyvs1 = yyvs;
	short *yyss1 = yyss;


	/* Each stack pointer address is followed by the size of the
	   data in use in that stack, in bytes.  This used to be a
	   conditional around just the two extra args, but that might
	   be undefined if yyoverflow is a macro.  */
	yyoverflow ("parser stack overflow",
		    &yyss1, yysize * sizeof (*yyssp),
		    &yyvs1, yysize * sizeof (*yyvsp),

		    &yystacksize);

	yyss = yyss1;
	yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyoverflowlab;
# else
      /* Extend the stack our own way.  */
      if (yystacksize >= YYMAXDEPTH)
	goto yyoverflowlab;
      yystacksize *= 2;
      if (yystacksize > YYMAXDEPTH)
	yystacksize = YYMAXDEPTH;

      {
	short *yyss1 = yyss;
	union yyalloc *yyptr =
	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
	if (! yyptr)
	  goto yyoverflowlab;
	YYSTACK_RELOCATE (yyss);
	YYSTACK_RELOCATE (yyvs);

#  undef YYSTACK_RELOCATE
	if (yyss1 != yyssa)
	  YYSTACK_FREE (yyss1);
      }
# endif
#endif /* no yyoverflow */

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;


      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
		  (unsigned long int) yystacksize));

      if (yyssp >= yyss + yystacksize - 1)
	YYABORT;
    }

  YYDPRINTF ((stderr, "Entering state %d\n", yystate));

  goto yybackup;

/*-----------.
| yybackup.  |
`-----------*/
yybackup:

/* Do appropriate processing given the current state.  */
/* Read a lookahead token if we need one and don't already have one.  */
/* yyresume: */

  /* First try to decide what to do without reference to lookahead token.  */

  yyn = yypact[yystate];
  if (yyn == YYPACT_NINF)
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* yychar is either YYEMPTY or YYEOF
     or a valid token in external form.  */

  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = YYLEX;
    }

  /* Convert token to internal form (in yychar1) for indexing tables with.  */

  if (yychar <= 0)		/* This means end of input.  */
    {
      yychar1 = 0;
      yychar = YYEOF;		/* Don't call YYLEX any more.  */

      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yychar1 = YYTRANSLATE (yychar);

      /* We have to keep this `#if YYDEBUG', since we use variables
	 which are defined only if `YYDEBUG' is set.  */
      YYDPRINTF ((stderr, "Next token is "));
      YYDSYMPRINT ((stderr, yychar1, yylval));
      YYDPRINTF ((stderr, "\n"));
    }

  /* If the proper action on seeing token YYCHAR1 is to reduce or to
     detect an error, take that action.  */
  yyn += yychar1;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yyn == 0 || yyn == YYTABLE_NINF)
	goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  if (yyn == YYFINAL)
    YYACCEPT;

  /* Shift the lookahead token.  */
  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
	      yychar, yytname[yychar1]));

  /* Discard the token being shifted unless it is eof.  */
  if (yychar != YYEOF)
    yychar = YYEMPTY;

  *++yyvsp = yylval;


  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  yystate = yyn;
  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- Do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];



#if YYDEBUG
  /* We have to keep this `#if YYDEBUG', since we use variables which
     are defined only if `YYDEBUG' is set.  */
  if (yydebug)
    {
      int yyi;

      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
		 yyn - 1, yyrline[yyn]);

      /* Print the symbols being reduced, and their result.  */
      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
    }
#endif
  switch (yyn)
    {
        case 2:
#line 267 "parse.y"
    {
		        yyval.vars = ruby_dyna_vars;
			lex_state = EXPR_BEG;
                        top_local_init();
			if ((VALUE)ruby_class == rb_cObject) class_nest = 0;
			else class_nest = 1;
		    }
    break;

  case 3:
#line 275 "parse.y"
    {
			if (yyvsp[0].node && !compile_for_eval) {
                            /* last expression should not be void */
			    if (nd_type(yyvsp[0].node) != NODE_BLOCK) void_expr(yyvsp[0].node);
			    else {
				NODE *node = yyvsp[0].node;
				while (node->nd_next) {
				    node = node->nd_next;
				}
				void_expr(node->nd_head);
			    }
			}
			ruby_eval_tree = block_append(ruby_eval_tree, yyvsp[0].node);
                        top_local_setup();
			class_nest = 0;
		        ruby_dyna_vars = yyvsp[-1].vars;
		    }
    break;

  case 4:
#line 295 "parse.y"
    {
			void_stmts(yyvsp[-1].node);
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 6:
#line 303 "parse.y"
    {
			yyval.node = newline_node(yyvsp[0].node);
		    }
    break;

  case 7:
#line 307 "parse.y"
    {
			yyval.node = block_append(yyvsp[-2].node, newline_node(yyvsp[0].node));
		    }
    break;

  case 8:
#line 311 "parse.y"
    {
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 9:
#line 316 "parse.y"
    {lex_state = EXPR_FNAME;}
    break;

  case 10:
#line 317 "parse.y"
    {
			if (in_def || in_single)
			    yyerror("alias within method");
		        yyval.node = NEW_ALIAS(yyvsp[-2].id, yyvsp[0].id);
		    }
    break;

  case 11:
#line 323 "parse.y"
    {
			if (in_def || in_single)
			    yyerror("alias within method");
		        yyval.node = NEW_VALIAS(yyvsp[-1].id, yyvsp[0].id);
		    }
    break;

  case 12:
#line 329 "parse.y"
    {
			char buf[3];

			if (in_def || in_single)
			    yyerror("alias within method");
			sprintf(buf, "$%c", (int)yyvsp[0].node->nd_nth);
		        yyval.node = NEW_VALIAS(yyvsp[-1].id, rb_intern(buf));
		    }
    break;

  case 13:
#line 338 "parse.y"
    {
		        yyerror("can't make alias for the number variables");
		        yyval.node = 0;
		    }
    break;

  case 14:
#line 343 "parse.y"
    {
			if (in_def || in_single)
			    yyerror("undef within method");
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 15:
#line 349 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_IF(cond(yyvsp[0].node), yyvsp[-2].node, 0);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;

  case 16:
#line 355 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_UNLESS(cond(yyvsp[0].node), yyvsp[-2].node, 0);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;

  case 17:
#line 361 "parse.y"
    {
			value_expr(yyvsp[0].node);
			if (yyvsp[-2].node && nd_type(yyvsp[-2].node) == NODE_BEGIN) {
			    yyval.node = NEW_WHILE(cond(yyvsp[0].node), yyvsp[-2].node->nd_body, 0);
			}
			else {
			    yyval.node = NEW_WHILE(cond(yyvsp[0].node), yyvsp[-2].node, 1);
			}
		    }
    break;

  case 18:
#line 371 "parse.y"
    {
			value_expr(yyvsp[0].node);
			if (yyvsp[-2].node && nd_type(yyvsp[-2].node) == NODE_BEGIN) {
			    yyval.node = NEW_UNTIL(cond(yyvsp[0].node), yyvsp[-2].node->nd_body, 0);
			}
			else {
			    yyval.node = NEW_UNTIL(cond(yyvsp[0].node), yyvsp[-2].node, 1);
			}
		    }
    break;

  case 19:
#line 381 "parse.y"
    {
			yyval.node = NEW_RESCUE(yyvsp[-2].node, NEW_RESBODY(0,yyvsp[0].node,0), 0);
		    }
    break;

  case 20:
#line 385 "parse.y"
    {
			if (in_def || in_single) {
			    yyerror("BEGIN in method");
			}
			local_push(0);
		    }
    break;

  case 21:
#line 392 "parse.y"
    {
			ruby_eval_tree_begin = block_append(ruby_eval_tree_begin,
						            NEW_PREEXE(yyvsp[-1].node));
		        local_pop();
		        yyval.node = 0;
		    }
    break;

  case 22:
#line 399 "parse.y"
    {
			if (compile_for_eval && (in_def || in_single)) {
			    yyerror("END in method; use at_exit");
			}

			yyval.node = NEW_ITER(0, NEW_POSTEXE(), yyvsp[-1].node);
		    }
    break;

  case 23:
#line 407 "parse.y"
    {
			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 24:
#line 411 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyvsp[-2].node->nd_value = yyvsp[0].node;
			yyval.node = yyvsp[-2].node;
		    }
    break;

  case 25:
#line 417 "parse.y"
    {
			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 27:
#line 424 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyvsp[-2].node->nd_value = yyvsp[0].node;
			yyval.node = yyvsp[-2].node;
		    }
    break;

  case 28:
#line 430 "parse.y"
    {
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			yyval.node = NEW_RETURN(yyvsp[0].node);
		    }
    break;

  case 30:
#line 437 "parse.y"
    {
			yyval.node = logop(NODE_AND, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 31:
#line 441 "parse.y"
    {
			yyval.node = logop(NODE_OR, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 32:
#line 445 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_NOT(cond(yyvsp[0].node));
		    }
    break;

  case 33:
#line 450 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_NOT(cond(yyvsp[0].node));
		    }
    break;

  case 38:
#line 463 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;

  case 39:
#line 468 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;

  case 40:
#line 475 "parse.y"
    {
			yyval.node = new_fcall(yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		   }
    break;

  case 41:
#line 480 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;

  case 42:
#line 486 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;

  case 43:
#line 492 "parse.y"
    {
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("super called outside of method");
			yyval.node = new_super(yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;

  case 44:
#line 499 "parse.y"
    {
			yyval.node = NEW_YIELD(yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;

  case 46:
#line 507 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 48:
#line 514 "parse.y"
    {
			yyval.node = NEW_MASGN(NEW_LIST(yyvsp[-1].node), 0);
		    }
    break;

  case 49:
#line 520 "parse.y"
    {
			yyval.node = NEW_MASGN(yyvsp[0].node, 0);
		    }
    break;

  case 50:
#line 524 "parse.y"
    {
			yyval.node = NEW_MASGN(list_append(yyvsp[-1].node,yyvsp[0].node), 0);
		    }
    break;

  case 51:
#line 528 "parse.y"
    {
			yyval.node = NEW_MASGN(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 52:
#line 532 "parse.y"
    {
			yyval.node = NEW_MASGN(yyvsp[-1].node, -1);
		    }
    break;

  case 53:
#line 536 "parse.y"
    {
			yyval.node = NEW_MASGN(0, yyvsp[0].node);
		    }
    break;

  case 54:
#line 540 "parse.y"
    {
			yyval.node = NEW_MASGN(0, -1);
		    }
    break;

  case 56:
#line 547 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 57:
#line 553 "parse.y"
    {
			yyval.node = NEW_LIST(yyvsp[-1].node);
		    }
    break;

  case 58:
#line 557 "parse.y"
    {
			yyval.node = list_append(yyvsp[-2].node, yyvsp[-1].node);
		    }
    break;

  case 59:
#line 563 "parse.y"
    {
			yyval.node = assignable(yyvsp[0].id, 0);
		    }
    break;

  case 60:
#line 567 "parse.y"
    {
			yyval.node = aryset(yyvsp[-3].node, yyvsp[-1].node);
		    }
    break;

  case 61:
#line 571 "parse.y"
    {
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 62:
#line 575 "parse.y"
    {
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 63:
#line 579 "parse.y"
    {
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 64:
#line 583 "parse.y"
    {
		        rb_backref_error(yyvsp[0].node);
			yyval.node = 0;
		    }
    break;

  case 65:
#line 590 "parse.y"
    {
			yyval.node = assignable(yyvsp[0].id, 0);
		    }
    break;

  case 66:
#line 594 "parse.y"
    {
			yyval.node = aryset(yyvsp[-3].node, yyvsp[-1].node);
		    }
    break;

  case 67:
#line 598 "parse.y"
    {
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 68:
#line 602 "parse.y"
    {
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 69:
#line 606 "parse.y"
    {
			yyval.node = attrset(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 70:
#line 610 "parse.y"
    {
		        rb_backref_error(yyvsp[0].node);
			yyval.node = 0;
		    }
    break;

  case 71:
#line 617 "parse.y"
    {
			yyerror("class/module name must be CONSTANT");
		    }
    break;

  case 76:
#line 627 "parse.y"
    {
			lex_state = EXPR_END;
			yyval.id = yyvsp[0].id;
		    }
    break;

  case 77:
#line 632 "parse.y"
    {
			lex_state = EXPR_END;
			yyval.id = yyvsp[0].id;
		    }
    break;

  case 80:
#line 643 "parse.y"
    {
			yyval.node = NEW_UNDEF(yyvsp[0].id);
		    }
    break;

  case 81:
#line 646 "parse.y"
    {lex_state = EXPR_FNAME;}
    break;

  case 82:
#line 647 "parse.y"
    {
			yyval.node = block_append(yyvsp[-3].node, NEW_UNDEF(yyvsp[0].id));
		    }
    break;

  case 83:
#line 652 "parse.y"
    { yyval.id = '|'; }
    break;

  case 84:
#line 653 "parse.y"
    { yyval.id = '^'; }
    break;

  case 85:
#line 654 "parse.y"
    { yyval.id = '&'; }
    break;

  case 86:
#line 655 "parse.y"
    { yyval.id = tCMP; }
    break;

  case 87:
#line 656 "parse.y"
    { yyval.id = tEQ; }
    break;

  case 88:
#line 657 "parse.y"
    { yyval.id = tEQQ; }
    break;

  case 89:
#line 658 "parse.y"
    { yyval.id = tMATCH; }
    break;

  case 90:
#line 659 "parse.y"
    { yyval.id = '>'; }
    break;

  case 91:
#line 660 "parse.y"
    { yyval.id = tGEQ; }
    break;

  case 92:
#line 661 "parse.y"
    { yyval.id = '<'; }
    break;

  case 93:
#line 662 "parse.y"
    { yyval.id = tLEQ; }
    break;

  case 94:
#line 663 "parse.y"
    { yyval.id = tLSHFT; }
    break;

  case 95:
#line 664 "parse.y"
    { yyval.id = tRSHFT; }
    break;

  case 96:
#line 665 "parse.y"
    { yyval.id = '+'; }
    break;

  case 97:
#line 666 "parse.y"
    { yyval.id = '-'; }
    break;

  case 98:
#line 667 "parse.y"
    { yyval.id = '*'; }
    break;

  case 99:
#line 668 "parse.y"
    { yyval.id = '*'; }
    break;

  case 100:
#line 669 "parse.y"
    { yyval.id = '/'; }
    break;

  case 101:
#line 670 "parse.y"
    { yyval.id = '%'; }
    break;

  case 102:
#line 671 "parse.y"
    { yyval.id = tPOW; }
    break;

  case 103:
#line 672 "parse.y"
    { yyval.id = '~'; }
    break;

  case 104:
#line 673 "parse.y"
    { yyval.id = tUPLUS; }
    break;

  case 105:
#line 674 "parse.y"
    { yyval.id = tUMINUS; }
    break;

  case 106:
#line 675 "parse.y"
    { yyval.id = tAREF; }
    break;

  case 107:
#line 676 "parse.y"
    { yyval.id = tASET; }
    break;

  case 108:
#line 677 "parse.y"
    { yyval.id = '`'; }
    break;

  case 150:
#line 690 "parse.y"
    {
			yyval.node = node_assign(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 151:
#line 693 "parse.y"
    {yyval.node = assignable(yyvsp[-1].id, 0);}
    break;

  case 152:
#line 694 "parse.y"
    {
			value_expr(yyvsp[0].node);
			if (yyvsp[-1].node) {
			    if (yyvsp[-2].id == tOROP) {
				yyvsp[-1].node->nd_value = yyvsp[0].node;
				yyval.node = NEW_OP_ASGN_OR(gettable(yyvsp[-3].id), yyvsp[-1].node);
				if (is_instance_id(yyvsp[-3].id)) {
				    yyval.node->nd_aid = yyvsp[-3].id;
				}
			    }
			    else if (yyvsp[-2].id == tANDOP) {
				yyvsp[-1].node->nd_value = yyvsp[0].node;
				yyval.node = NEW_OP_ASGN_AND(gettable(yyvsp[-3].id), yyvsp[-1].node);
			    }
			    else {
				yyval.node = yyvsp[-1].node;
				yyval.node->nd_value = call_op(gettable(yyvsp[-3].id),yyvsp[-2].id,1,yyvsp[0].node);
			    }
			    fixpos(yyval.node, yyvsp[0].node);
			}
			else {
			    yyval.node = 0;
			}
		    }
    break;

  case 153:
#line 719 "parse.y"
    {
                        NODE *args = NEW_LIST(yyvsp[0].node);

			value_expr(yyvsp[0].node);
			yyvsp[-3].node = list_append(yyvsp[-3].node, NEW_NIL());
			list_concat(args, yyvsp[-3].node);
			if (yyvsp[-1].id == tOROP) {
			    yyvsp[-1].id = 0;
			}
			else if (yyvsp[-1].id == tANDOP) {
			    yyvsp[-1].id = 1;
			}
			yyval.node = NEW_OP_ASGN1(yyvsp[-5].node, yyvsp[-1].id, args);
		        fixpos(yyval.node, yyvsp[-5].node);
		    }
    break;

  case 154:
#line 735 "parse.y"
    {
			value_expr(yyvsp[0].node);
			if (yyvsp[-1].id == tOROP) {
			    yyvsp[-1].id = 0;
			}
			else if (yyvsp[-1].id == tANDOP) {
			    yyvsp[-1].id = 1;
			}
			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 155:
#line 747 "parse.y"
    {
			value_expr(yyvsp[0].node);
			if (yyvsp[-1].id == tOROP) {
			    yyvsp[-1].id = 0;
			}
			else if (yyvsp[-1].id == tANDOP) {
			    yyvsp[-1].id = 1;
			}
			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 156:
#line 759 "parse.y"
    {
			value_expr(yyvsp[0].node);
			if (yyvsp[-1].id == tOROP) {
			    yyvsp[-1].id = 0;
			}
			else if (yyvsp[-1].id == tANDOP) {
			    yyvsp[-1].id = 1;
			}
			yyval.node = NEW_OP_ASGN2(yyvsp[-4].node, yyvsp[-2].id, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 157:
#line 771 "parse.y"
    {
		        rb_backref_error(yyvsp[-2].node);
			yyval.node = 0;
		    }
    break;

  case 158:
#line 776 "parse.y"
    {
			value_expr(yyvsp[-2].node);
			value_expr(yyvsp[0].node);
			yyval.node = NEW_DOT2(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 159:
#line 782 "parse.y"
    {
			value_expr(yyvsp[-2].node);
			value_expr(yyvsp[0].node);
			yyval.node = NEW_DOT3(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 160:
#line 788 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '+', 1, yyvsp[0].node);
		    }
    break;

  case 161:
#line 792 "parse.y"
    {
		        yyval.node = call_op(yyvsp[-2].node, '-', 1, yyvsp[0].node);
		    }
    break;

  case 162:
#line 796 "parse.y"
    {
		        yyval.node = call_op(yyvsp[-2].node, '*', 1, yyvsp[0].node);
		    }
    break;

  case 163:
#line 800 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '/', 1, yyvsp[0].node);
		    }
    break;

  case 164:
#line 804 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '%', 1, yyvsp[0].node);
		    }
    break;

  case 165:
#line 808 "parse.y"
    {
			int need_negate = Qfalse;

			if (yyvsp[-2].node && nd_type(yyvsp[-2].node) == NODE_LIT) {

			    switch (TYPE(yyvsp[-2].node->nd_lit)) {
			      case T_FIXNUM:
			      case T_FLOAT:
			      case T_BIGNUM:
				if (RTEST(rb_funcall(yyvsp[-2].node->nd_lit,'<',1,INT2FIX(0)))) {
				    yyvsp[-2].node->nd_lit = rb_funcall(yyvsp[-2].node->nd_lit,rb_intern("-@"),0,0);
				    need_negate = Qtrue;
				}
			      default:
				break;
			    }
			}
			yyval.node = call_op(yyvsp[-2].node, tPOW, 1, yyvsp[0].node);
			if (need_negate) {
			    yyval.node = call_op(yyval.node, tUMINUS, 0, 0);
			}
		    }
    break;

  case 166:
#line 831 "parse.y"
    {
			if (yyvsp[0].node && nd_type(yyvsp[0].node) == NODE_LIT) {
			    yyval.node = yyvsp[0].node;
			}
			else {
			    yyval.node = call_op(yyvsp[0].node, tUPLUS, 0, 0);
			}
		    }
    break;

  case 167:
#line 840 "parse.y"
    {
			if (yyvsp[0].node && nd_type(yyvsp[0].node) == NODE_LIT && FIXNUM_P(yyvsp[0].node->nd_lit)) {
			    long i = FIX2LONG(yyvsp[0].node->nd_lit);

			    yyvsp[0].node->nd_lit = INT2NUM(-i);
			    yyval.node = yyvsp[0].node;
			}
			else {
			    yyval.node = call_op(yyvsp[0].node, tUMINUS, 0, 0);
			}
		    }
    break;

  case 168:
#line 852 "parse.y"
    {
		        yyval.node = call_op(yyvsp[-2].node, '|', 1, yyvsp[0].node);
		    }
    break;

  case 169:
#line 856 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '^', 1, yyvsp[0].node);
		    }
    break;

  case 170:
#line 860 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '&', 1, yyvsp[0].node);
		    }
    break;

  case 171:
#line 864 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tCMP, 1, yyvsp[0].node);
		    }
    break;

  case 172:
#line 868 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '>', 1, yyvsp[0].node);
		    }
    break;

  case 173:
#line 872 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tGEQ, 1, yyvsp[0].node);
		    }
    break;

  case 174:
#line 876 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, '<', 1, yyvsp[0].node);
		    }
    break;

  case 175:
#line 880 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tLEQ, 1, yyvsp[0].node);
		    }
    break;

  case 176:
#line 884 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tEQ, 1, yyvsp[0].node);
		    }
    break;

  case 177:
#line 888 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tEQQ, 1, yyvsp[0].node);
		    }
    break;

  case 178:
#line 892 "parse.y"
    {
			yyval.node = NEW_NOT(call_op(yyvsp[-2].node, tEQ, 1, yyvsp[0].node));
		    }
    break;

  case 179:
#line 896 "parse.y"
    {
			yyval.node = match_gen(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 180:
#line 900 "parse.y"
    {
			yyval.node = NEW_NOT(match_gen(yyvsp[-2].node, yyvsp[0].node));
		    }
    break;

  case 181:
#line 904 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_NOT(cond(yyvsp[0].node));
		    }
    break;

  case 182:
#line 909 "parse.y"
    {
			yyval.node = call_op(yyvsp[0].node, '~', 0, 0);
		    }
    break;

  case 183:
#line 913 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tLSHFT, 1, yyvsp[0].node);
		    }
    break;

  case 184:
#line 917 "parse.y"
    {
			yyval.node = call_op(yyvsp[-2].node, tRSHFT, 1, yyvsp[0].node);
		    }
    break;

  case 185:
#line 921 "parse.y"
    {
			yyval.node = logop(NODE_AND, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 186:
#line 925 "parse.y"
    {
			yyval.node = logop(NODE_OR, yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 187:
#line 928 "parse.y"
    {in_defined = 1;}
    break;

  case 188:
#line 929 "parse.y"
    {
		        in_defined = 0;
			yyval.node = NEW_DEFINED(yyvsp[0].node);
		    }
    break;

  case 189:
#line 934 "parse.y"
    {
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_IF(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 190:
#line 940 "parse.y"
    {
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 192:
#line 947 "parse.y"
    {
			yyval.node = NEW_LIST(yyvsp[-1].node);
		    }
    break;

  case 193:
#line 951 "parse.y"
    {
			yyval.node = list_append(yyvsp[-3].node, yyvsp[-1].node);
		    }
    break;

  case 194:
#line 955 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 195:
#line 959 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = arg_concat(yyvsp[-4].node, yyvsp[-1].node);
		    }
    break;

  case 196:
#line 964 "parse.y"
    {
			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
		    }
    break;

  case 197:
#line 968 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = NEW_RESTARGS(yyvsp[-1].node);
		    }
    break;

  case 198:
#line 975 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 199:
#line 979 "parse.y"
    {
			yyval.node = yyvsp[-2].node;
		    }
    break;

  case 200:
#line 983 "parse.y"
    {
			yyval.node = NEW_LIST(yyvsp[-2].node);
		    }
    break;

  case 201:
#line 987 "parse.y"
    {
			yyval.node = list_append(yyvsp[-4].node, yyvsp[-2].node);
		    }
    break;

  case 204:
#line 997 "parse.y"
    {
			yyval.node = NEW_LIST(yyvsp[0].node);
		    }
    break;

  case 205:
#line 1001 "parse.y"
    {
			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 206:
#line 1005 "parse.y"
    {
			yyval.node = arg_blk_pass(yyvsp[-1].node, yyvsp[0].node);
		    }
    break;

  case 207:
#line 1009 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = arg_concat(yyvsp[-4].node, yyvsp[-1].node);
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;

  case 208:
#line 1015 "parse.y"
    {
			yyval.node = NEW_LIST(NEW_HASH(yyvsp[-1].node));
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;

  case 209:
#line 1020 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = arg_concat(NEW_LIST(NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;

  case 210:
#line 1026 "parse.y"
    {
			yyval.node = list_append(yyvsp[-3].node, NEW_HASH(yyvsp[-1].node));
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;

  case 211:
#line 1031 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = arg_concat(list_append(yyvsp[-6].node, NEW_HASH(yyvsp[-4].node)), yyvsp[-1].node);
			yyval.node = arg_blk_pass(yyval.node, yyvsp[0].node);
		    }
    break;

  case 212:
#line 1037 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = arg_blk_pass(NEW_RESTARGS(yyvsp[-1].node), yyvsp[0].node);
		    }
    break;

  case 214:
#line 1044 "parse.y"
    {CMDARG_PUSH;}
    break;

  case 215:
#line 1045 "parse.y"
    {
		        CMDARG_POP;
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 216:
#line 1052 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_BLOCK_PASS(yyvsp[0].node);
		    }
    break;

  case 217:
#line 1059 "parse.y"
    {
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 219:
#line 1066 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_LIST(yyvsp[0].node);
		    }
    break;

  case 220:
#line 1071 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 221:
#line 1078 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 223:
#line 1086 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = list_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 224:
#line 1091 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = arg_concat(yyvsp[-3].node, yyvsp[0].node);
		    }
    break;

  case 225:
#line 1096 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 226:
#line 1103 "parse.y"
    {
			yyval.node = yyvsp[0].node;
			if (yyvsp[0].node) {
			    if (nd_type(yyvsp[0].node) == NODE_ARRAY &&
				yyvsp[0].node->nd_next == 0) {
				yyval.node = yyvsp[0].node->nd_head;
			    }
			    else if (nd_type(yyvsp[0].node) == NODE_BLOCK_PASS) {
				rb_compile_error("block argument should not be given");
			    }
			}
		    }
    break;

  case 227:
#line 1118 "parse.y"
    {
			yyval.node = NEW_LIT(yyvsp[0].val);
		    }
    break;

  case 229:
#line 1123 "parse.y"
    {
			yyval.node = NEW_XSTR(yyvsp[0].val);
		    }
    break;

  case 235:
#line 1132 "parse.y"
    {
			yyval.node = NEW_VCALL(yyvsp[0].id);
		    }
    break;

  case 236:
#line 1141 "parse.y"
    {
			if (!yyvsp[-3].node && !yyvsp[-2].node && !yyvsp[-1].node)
			    yyval.node = NEW_BEGIN(yyvsp[-4].node);
			else {
			    if (yyvsp[-3].node) yyvsp[-4].node = NEW_RESCUE(yyvsp[-4].node, yyvsp[-3].node, yyvsp[-2].node);
			    else if (yyvsp[-2].node) {
				rb_warn("else without rescue is useless");
				yyvsp[-4].node = block_append(yyvsp[-4].node, yyvsp[-2].node);
			    }
			    if (yyvsp[-1].node) yyvsp[-4].node = NEW_ENSURE(yyvsp[-4].node, yyvsp[-1].node);
			    yyval.node = yyvsp[-4].node;
			}
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 237:
#line 1156 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 238:
#line 1160 "parse.y"
    {
			value_expr(yyvsp[-2].node);
			yyval.node = NEW_COLON2(yyvsp[-2].node, yyvsp[0].id);
		    }
    break;

  case 239:
#line 1165 "parse.y"
    {
			yyval.node = NEW_COLON3(yyvsp[0].id);
		    }
    break;

  case 240:
#line 1169 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = NEW_CALL(yyvsp[-3].node, tAREF, yyvsp[-1].node);
		    }
    break;

  case 241:
#line 1174 "parse.y"
    {
			if (yyvsp[-1].node == 0)
			    yyval.node = NEW_ZARRAY(); /* zero length array*/
			else {
			    yyval.node = yyvsp[-1].node;
			}
		    }
    break;

  case 242:
#line 1182 "parse.y"
    {
			yyval.node = NEW_HASH(yyvsp[-1].node);
		    }
    break;

  case 243:
#line 1186 "parse.y"
    {
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			value_expr(yyvsp[-1].node);
			yyval.node = NEW_RETURN(yyvsp[-1].node);
		    }
    break;

  case 244:
#line 1193 "parse.y"
    {
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			yyval.node = NEW_RETURN(0);
		    }
    break;

  case 245:
#line 1199 "parse.y"
    {
			if (!compile_for_eval && !in_def && !in_single)
			    yyerror("return appeared outside of method");
			yyval.node = NEW_RETURN(0);
		    }
    break;

  case 246:
#line 1205 "parse.y"
    {
			value_expr(yyvsp[-1].node);
			yyval.node = NEW_YIELD(yyvsp[-1].node);
		    }
    break;

  case 247:
#line 1210 "parse.y"
    {
			yyval.node = NEW_YIELD(0);
		    }
    break;

  case 248:
#line 1214 "parse.y"
    {
			yyval.node = NEW_YIELD(0);
		    }
    break;

  case 249:
#line 1217 "parse.y"
    {in_defined = 1;}
    break;

  case 250:
#line 1218 "parse.y"
    {
		        in_defined = 0;
			yyval.node = NEW_DEFINED(yyvsp[-1].node);
		    }
    break;

  case 251:
#line 1223 "parse.y"
    {
			yyvsp[0].node->nd_iter = NEW_FCALL(yyvsp[-1].id, 0);
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 253:
#line 1229 "parse.y"
    {
			if (yyvsp[-1].node && nd_type(yyvsp[-1].node) == NODE_BLOCK_PASS) {
			    rb_compile_error("both block arg and actual block given");
			}
			yyvsp[0].node->nd_iter = yyvsp[-1].node;
			yyval.node = yyvsp[0].node;
		        fixpos(yyval.node, yyvsp[-1].node);
		    }
    break;

  case 254:
#line 1241 "parse.y"
    {
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_IF(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 255:
#line 1250 "parse.y"
    {
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_UNLESS(cond(yyvsp[-4].node), yyvsp[-2].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 256:
#line 1255 "parse.y"
    {COND_PUSH;}
    break;

  case 257:
#line 1255 "parse.y"
    {COND_POP;}
    break;

  case 258:
#line 1258 "parse.y"
    {
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_WHILE(cond(yyvsp[-4].node), yyvsp[-1].node, 1);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 259:
#line 1263 "parse.y"
    {COND_PUSH;}
    break;

  case 260:
#line 1263 "parse.y"
    {COND_POP;}
    break;

  case 261:
#line 1266 "parse.y"
    {
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_UNTIL(cond(yyvsp[-4].node), yyvsp[-1].node, 1);
		        fixpos(yyval.node, yyvsp[-4].node);
		    }
    break;

  case 262:
#line 1274 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = NEW_CASE(yyvsp[-3].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;

  case 263:
#line 1280 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 264:
#line 1283 "parse.y"
    {COND_PUSH;}
    break;

  case 265:
#line 1283 "parse.y"
    {COND_POP;}
    break;

  case 266:
#line 1286 "parse.y"
    {
			value_expr(yyvsp[-4].node);
			yyval.node = NEW_FOR(yyvsp[-7].node, yyvsp[-4].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-7].node);
		    }
    break;

  case 267:
#line 1292 "parse.y"
    {
			if (in_def || in_single)
			    yyerror("class definition in method body");
			class_nest++;
			local_push(0);
		        yyval.num = ruby_sourceline;
		    }
    break;

  case 268:
#line 1301 "parse.y"
    {
		        yyval.node = NEW_CLASS(yyvsp[-4].id, yyvsp[-1].node, yyvsp[-3].node);
		        nd_set_line(yyval.node, yyvsp[-2].num);
		        local_pop();
			class_nest--;
		    }
    break;

  case 269:
#line 1308 "parse.y"
    {
			yyval.num = in_def;
		        in_def = 0;
		    }
    break;

  case 270:
#line 1313 "parse.y"
    {
		        yyval.num = in_single;
		        in_single = 0;
			class_nest++;
			local_push(0);
		    }
    break;

  case 271:
#line 1321 "parse.y"
    {
		        yyval.node = NEW_SCLASS(yyvsp[-5].node, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-5].node);
		        local_pop();
			class_nest--;
		        in_def = yyvsp[-4].num;
		        in_single = yyvsp[-2].num;
		    }
    break;

  case 272:
#line 1330 "parse.y"
    {
			if (in_def || in_single)
			    yyerror("module definition in method body");
			class_nest++;
			local_push(0);
		        yyval.num = ruby_sourceline;
		    }
    break;

  case 273:
#line 1339 "parse.y"
    {
		        yyval.node = NEW_MODULE(yyvsp[-3].id, yyvsp[-1].node);
		        nd_set_line(yyval.node, yyvsp[-2].num);
		        local_pop();
			class_nest--;
		    }
    break;

  case 274:
#line 1346 "parse.y"
    {
			if (in_def || in_single)
			    yyerror("nested method definition");
			yyval.id = cur_mid;
			cur_mid = yyvsp[0].id;
			in_def++;
			local_push(0);
		    }
    break;

  case 275:
#line 1360 "parse.y"
    {
		        if (yyvsp[-3].node) yyvsp[-4].node = NEW_RESCUE(yyvsp[-4].node, yyvsp[-3].node, yyvsp[-2].node);
			else if (yyvsp[-2].node) {
			    rb_warn("else without rescue is useless");
			    yyvsp[-4].node = block_append(yyvsp[-4].node, yyvsp[-2].node);
			}
			if (yyvsp[-1].node) yyvsp[-4].node = NEW_ENSURE(yyvsp[-4].node, yyvsp[-1].node);

			yyval.node = NEW_DEFN(yyvsp[-7].id, yyvsp[-5].node, yyvsp[-4].node, NOEX_PRIVATE);
			if (is_attrset_id(yyvsp[-7].id)) yyval.node->nd_noex = NOEX_PUBLIC;
		        fixpos(yyval.node, yyvsp[-5].node);
		        local_pop();
			in_def--;
			cur_mid = yyvsp[-6].id;
		    }
    break;

  case 276:
#line 1375 "parse.y"
    {lex_state = EXPR_FNAME;}
    break;

  case 277:
#line 1376 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			in_single++;
			local_push(0);
		        lex_state = EXPR_END; /* force for args */
		    }
    break;

  case 278:
#line 1388 "parse.y"
    {
		        if (yyvsp[-3].node) yyvsp[-4].node = NEW_RESCUE(yyvsp[-4].node, yyvsp[-3].node, yyvsp[-2].node);
			else if (yyvsp[-2].node) {
			    rb_warn("else without rescue is useless");
			    yyvsp[-4].node = block_append(yyvsp[-4].node, yyvsp[-2].node);
			}
			if (yyvsp[-1].node) yyvsp[-4].node = NEW_ENSURE(yyvsp[-4].node, yyvsp[-1].node);

			yyval.node = NEW_DEFS(yyvsp[-10].node, yyvsp[-7].id, yyvsp[-5].node, yyvsp[-4].node);
		        fixpos(yyval.node, yyvsp[-10].node);
		        local_pop();
			in_single--;
		    }
    break;

  case 279:
#line 1402 "parse.y"
    {
			yyval.node = NEW_BREAK();
		    }
    break;

  case 280:
#line 1406 "parse.y"
    {
			yyval.node = NEW_NEXT();
		    }
    break;

  case 281:
#line 1410 "parse.y"
    {
			yyval.node = NEW_REDO();
		    }
    break;

  case 282:
#line 1414 "parse.y"
    {
			yyval.node = NEW_RETRY();
		    }
    break;

  case 289:
#line 1432 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = NEW_IF(cond(yyvsp[-3].node), yyvsp[-1].node, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;

  case 291:
#line 1441 "parse.y"
    {
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 295:
#line 1452 "parse.y"
    {
			yyval.node = (NODE*)1;
		    }
    break;

  case 296:
#line 1456 "parse.y"
    {
			yyval.node = (NODE*)1;
		    }
    break;

  case 297:
#line 1460 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 298:
#line 1467 "parse.y"
    {
		        yyval.vars = dyna_push();
		    }
    break;

  case 299:
#line 1473 "parse.y"
    {
			yyval.node = NEW_ITER(yyvsp[-2].node, 0, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-2].node?yyvsp[-2].node:yyvsp[-1].node);
			dyna_pop(yyvsp[-3].vars);
		    }
    break;

  case 300:
#line 1481 "parse.y"
    {
			if (yyvsp[-1].node && nd_type(yyvsp[-1].node) == NODE_BLOCK_PASS) {
			    rb_compile_error("both block arg and actual block given");
			}
			yyvsp[0].node->nd_iter = yyvsp[-1].node;
			yyval.node = yyvsp[0].node;
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;

  case 301:
#line 1490 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;

  case 302:
#line 1495 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		    }
    break;

  case 303:
#line 1502 "parse.y"
    {
			yyval.node = new_fcall(yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[0].node);
		    }
    break;

  case 304:
#line 1507 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;

  case 305:
#line 1513 "parse.y"
    {
			value_expr(yyvsp[-3].node);
			yyval.node = new_call(yyvsp[-3].node, yyvsp[-1].id, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-3].node);
		    }
    break;

  case 306:
#line 1519 "parse.y"
    {
			value_expr(yyvsp[-2].node);
			yyval.node = new_call(yyvsp[-2].node, yyvsp[0].id, 0);
		    }
    break;

  case 307:
#line 1524 "parse.y"
    {
			if (!compile_for_eval && !in_def &&
		            !in_single && !in_defined)
			    yyerror("super called outside of method");
			yyval.node = new_super(yyvsp[0].node);
		    }
    break;

  case 308:
#line 1531 "parse.y"
    {
			if (!compile_for_eval && !in_def &&
		            !in_single && !in_defined)
			    yyerror("super called outside of method");
			yyval.node = NEW_ZSUPER();
		    }
    break;

  case 309:
#line 1540 "parse.y"
    {
		        yyval.vars = dyna_push();
		    }
    break;

  case 310:
#line 1545 "parse.y"
    {
			yyval.node = NEW_ITER(yyvsp[-2].node, 0, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-1].node);
			dyna_pop(yyvsp[-3].vars);
		    }
    break;

  case 311:
#line 1551 "parse.y"
    {
		        yyval.vars = dyna_push();
		    }
    break;

  case 312:
#line 1556 "parse.y"
    {
			yyval.node = NEW_ITER(yyvsp[-2].node, 0, yyvsp[-1].node);
		        fixpos(yyval.node, yyvsp[-1].node);
			dyna_pop(yyvsp[-3].vars);
		    }
    break;

  case 313:
#line 1566 "parse.y"
    {
			yyval.node = NEW_WHEN(yyvsp[-3].node, yyvsp[-1].node, yyvsp[0].node);
		    }
    break;

  case 315:
#line 1573 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = list_append(yyvsp[-3].node, NEW_WHEN(yyvsp[0].node, 0, 0));
		    }
    break;

  case 316:
#line 1578 "parse.y"
    {
			value_expr(yyvsp[0].node);
			yyval.node = NEW_LIST(NEW_WHEN(yyvsp[0].node, 0, 0));
		    }
    break;

  case 321:
#line 1593 "parse.y"
    {
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 323:
#line 1602 "parse.y"
    {
		        if (yyvsp[-3].node) {
		            yyvsp[-3].node = node_assign(yyvsp[-3].node, NEW_GVAR(rb_intern("$!")));
			    yyvsp[-1].node = block_append(yyvsp[-3].node, yyvsp[-1].node);
			}
			yyval.node = NEW_RESBODY(yyvsp[-4].node, yyvsp[-1].node, yyvsp[0].node);
		        fixpos(yyval.node, yyvsp[-4].node?yyvsp[-4].node:yyvsp[-1].node);
		    }
    break;

  case 326:
#line 1615 "parse.y"
    {
			if (yyvsp[0].node)
			    yyval.node = yyvsp[0].node;
			else
			    /* place holder */
			    yyval.node = NEW_NIL();
		    }
    break;

  case 328:
#line 1626 "parse.y"
    {
			yyval.val = ID2SYM(yyvsp[0].id);
		    }
    break;

  case 330:
#line 1633 "parse.y"
    {
			yyval.node = NEW_STR(yyvsp[0].val);
		    }
    break;

  case 332:
#line 1638 "parse.y"
    {
		        if (nd_type(yyvsp[-1].node) == NODE_DSTR) {
			    list_append(yyvsp[-1].node, NEW_STR(yyvsp[0].val));
			}
			else {
			    rb_str_concat(yyvsp[-1].node->nd_lit, yyvsp[0].val);
			}
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 333:
#line 1648 "parse.y"
    {
		        if (nd_type(yyvsp[-1].node) == NODE_STR) {
			    yyval.node = NEW_DSTR(yyvsp[-1].node->nd_lit);
			}
			else {
			    yyval.node = yyvsp[-1].node;
			}
			yyvsp[0].node->nd_head = NEW_STR(yyvsp[0].node->nd_lit);
			nd_set_type(yyvsp[0].node, NODE_ARRAY);
			list_concat(yyval.node, yyvsp[0].node);
		    }
    break;

  case 334:
#line 1662 "parse.y"
    {
		        lex_state = EXPR_END;
			yyval.id = yyvsp[0].id;
		    }
    break;

  case 346:
#line 1683 "parse.y"
    {yyval.id = kNIL;}
    break;

  case 347:
#line 1684 "parse.y"
    {yyval.id = kSELF;}
    break;

  case 348:
#line 1685 "parse.y"
    {yyval.id = kTRUE;}
    break;

  case 349:
#line 1686 "parse.y"
    {yyval.id = kFALSE;}
    break;

  case 350:
#line 1687 "parse.y"
    {yyval.id = k__FILE__;}
    break;

  case 351:
#line 1688 "parse.y"
    {yyval.id = k__LINE__;}
    break;

  case 352:
#line 1692 "parse.y"
    {
			yyval.node = gettable(yyvsp[0].id);
		    }
    break;

  case 355:
#line 1702 "parse.y"
    {
			yyval.node = 0;
		    }
    break;

  case 356:
#line 1706 "parse.y"
    {
			lex_state = EXPR_BEG;
		    }
    break;

  case 357:
#line 1710 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 358:
#line 1713 "parse.y"
    {yyerrok; yyval.node = 0;}
    break;

  case 359:
#line 1717 "parse.y"
    {
			yyval.node = yyvsp[-2].node;
			lex_state = EXPR_BEG;
		    }
    break;

  case 360:
#line 1722 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 361:
#line 1728 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(yyvsp[-5].num, yyvsp[-3].node, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;

  case 362:
#line 1732 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(yyvsp[-3].num, yyvsp[-1].node, -1), yyvsp[0].node);
		    }
    break;

  case 363:
#line 1736 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(yyvsp[-3].num, 0, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;

  case 364:
#line 1740 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(yyvsp[-1].num, 0, -1), yyvsp[0].node);
		    }
    break;

  case 365:
#line 1744 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(0, yyvsp[-3].node, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;

  case 366:
#line 1748 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(0, yyvsp[-1].node, -1), yyvsp[0].node);
		    }
    break;

  case 367:
#line 1752 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(0, 0, yyvsp[-1].id), yyvsp[0].node);
		    }
    break;

  case 368:
#line 1756 "parse.y"
    {
			yyval.node = block_append(NEW_ARGS(0, 0, -1), yyvsp[0].node);
		    }
    break;

  case 369:
#line 1760 "parse.y"
    {
			yyval.node = NEW_ARGS(0, 0, -1);
		    }
    break;

  case 370:
#line 1766 "parse.y"
    {
			yyerror("formal argument cannot be a constant");
		    }
    break;

  case 371:
#line 1770 "parse.y"
    {
                        yyerror("formal argument cannot be an instance variable");
		    }
    break;

  case 372:
#line 1774 "parse.y"
    {
                        yyerror("formal argument cannot be a global variable");
		    }
    break;

  case 373:
#line 1778 "parse.y"
    {
                        yyerror("formal argument cannot be a class variable");
		    }
    break;

  case 374:
#line 1782 "parse.y"
    {
			if (!is_local_id(yyvsp[0].id))
			    yyerror("formal argument must be local variable");
			else if (local_id(yyvsp[0].id))
			    yyerror("duplicate argument name");
			local_cnt(yyvsp[0].id);
			yyval.num = 1;
		    }
    break;

  case 376:
#line 1794 "parse.y"
    {
			yyval.num += 1;
		    }
    break;

  case 377:
#line 1800 "parse.y"
    {
			if (!is_local_id(yyvsp[-2].id))
			    yyerror("formal argument must be local variable");
			else if (local_id(yyvsp[-2].id))
			    yyerror("duplicate optional argument name");
			yyval.node = assignable(yyvsp[-2].id, yyvsp[0].node);
		    }
    break;

  case 378:
#line 1810 "parse.y"
    {
			yyval.node = NEW_BLOCK(yyvsp[0].node);
			yyval.node->nd_end = yyval.node;
		    }
    break;

  case 379:
#line 1815 "parse.y"
    {
			yyval.node = block_append(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 380:
#line 1821 "parse.y"
    {
			if (!is_local_id(yyvsp[0].id))
			    yyerror("rest argument must be local variable");
			else if (local_id(yyvsp[0].id))
			    yyerror("duplicate rest argument name");
			yyval.id = local_cnt(yyvsp[0].id);
		    }
    break;

  case 381:
#line 1829 "parse.y"
    {
			yyval.id = -2;
		    }
    break;

  case 382:
#line 1835 "parse.y"
    {
			if (!is_local_id(yyvsp[0].id))
			    yyerror("block argument must be local variable");
			else if (local_id(yyvsp[0].id))
			    yyerror("duplicate block argument name");
			yyval.node = NEW_BLOCK_ARG(yyvsp[0].id);
		    }
    break;

  case 383:
#line 1845 "parse.y"
    {
			yyval.node = yyvsp[0].node;
		    }
    break;

  case 385:
#line 1852 "parse.y"
    {
			if (nd_type(yyvsp[0].node) == NODE_SELF) {
			    yyval.node = NEW_SELF();
			}
			else {
			    yyval.node = yyvsp[0].node;
			}
		    }
    break;

  case 386:
#line 1860 "parse.y"
    {lex_state = EXPR_BEG;}
    break;

  case 387:
#line 1861 "parse.y"
    {
					if (yyvsp[-2].node == 0) {
			    yyerror("can't define single method for ().");
			}
			else {
			    switch (nd_type(yyvsp[-2].node)) {
			      case NODE_STR:
			      case NODE_DSTR:
			      case NODE_XSTR:
			      case NODE_DXSTR:
			      case NODE_DREGX:
			      case NODE_LIT:
			      case NODE_ARRAY:
			      case NODE_ZARRAY:
				yyerror("can't define single method for literals");
			      default:
				value_expr(yyvsp[-2].node);
				break;
			    }
			}
			yyval.node = yyvsp[-2].node;
		    }
    break;

  case 389:
#line 1887 "parse.y"
    {
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 390:
#line 1891 "parse.y"
    {
			if (yyvsp[-1].node->nd_alen%2 != 0) {
			    yyerror("odd number list for Hash");
			}
			yyval.node = yyvsp[-1].node;
		    }
    break;

  case 392:
#line 1901 "parse.y"
    {
			yyval.node = list_concat(yyvsp[-2].node, yyvsp[0].node);
		    }
    break;

  case 393:
#line 1907 "parse.y"
    {
			yyval.node = list_append(NEW_LIST(yyvsp[-2].node), yyvsp[0].node);
		    }
    break;

  case 413:
#line 1945 "parse.y"
    {yyerrok;}
    break;

  case 416:
#line 1950 "parse.y"
    {yyerrok;}
    break;

  case 417:
#line 1954 "parse.y"
    {
			yyval.node = 0;
		    }
    break;


    }

/* Line 1016 of /usr/local/share/bison/yacc.c.  */
#line 5663 "parse.c"