The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
case 2:
#line 150 "perly.y"
    { 
                            (yyval.ionlyval) = (ps[(1) - (2)].val.ionlyval); newPROG(block_end((ps[(1) - (2)].val.ionlyval),(ps[(2) - (2)].val.opval))); 
                        ;}
    break;

  case 3:
#line 157 "perly.y"
    {
                            (yyval.opval) = block_end((ps[(2) - (4)].val.ionlyval), (ps[(3) - (4)].val.opval));
                            TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 4:
#line 165 "perly.y"
    {
                            (yyval.opval) = block_end((ps[(2) - (4)].val.ionlyval), (ps[(3) - (4)].val.opval));
                            TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 5:
#line 173 "perly.y"
    { (yyval.ionlyval) = block_start(TRUE); ;}
    break;

  case 6:
#line 177 "perly.y"
    {
		    PL_parser->expect = XSTATE; (yyval.ionlyval) = block_start(TRUE);
		;}
    break;

  case 7:
#line 184 "perly.y"
    {
                            PL_parser->expect = XBLOCK;
                        ;}
    break;

  case 8:
#line 188 "perly.y"
    {
                            (yyval.opval) = block_end((ps[(3) - (5)].val.ionlyval), (ps[(4) - (5)].val.opval));
                            TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 9:
#line 196 "perly.y"
    { (yyval.ionlyval) = block_start(FALSE); ;}
    break;

  case 10:
#line 201 "perly.y"
    { (yyval.opval) = (OP*)NULL; ;}
    break;

  case 11:
#line 203 "perly.y"
    {
			(yyval.opval) = IF_MAD(
				append_list(OP_LINESEQ,
			    	    (LISTOP*)(ps[(1) - (2)].val.opval), (LISTOP*)(ps[(2) - (2)].val.opval)),
				(ps[(1) - (2)].val.opval));
			;}
    break;

  case 12:
#line 210 "perly.y"
    {   (yyval.opval) = append_list(OP_LINESEQ,
				(LISTOP*)(ps[(1) - (2)].val.opval), (LISTOP*)(ps[(2) - (2)].val.opval));
			    PL_pad_reset_pending = TRUE;
			    if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
				PL_hints |= HINT_BLOCK_SCOPE;
			;}
    break;

  case 13:
#line 220 "perly.y"
    {
                            (yyval.opval) = newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval), (ps[(1) - (1)].val.opval)->op_location);
                        ;}
    break;

  case 14:
#line 224 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 15:
#line 226 "perly.y"
    {
                            (yyval.opval) = IF_MAD( newOP(OP_NULL, 0, LOCATION((ps[(1) - (1)].val.i_tkval))),
                                    (OP*)NULL);
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),';');
                            APPEND_MADPROPS_PV("nullstatement",(yyval.opval),'>');
                            PL_parser->expect = XSTATE;
                        ;}
    break;

  case 16:
#line 234 "perly.y"
    {
                            SV* loc = (ps[(1) - (2)].val.opval) ? (ps[(1) - (2)].val.opval)->op_location : LOCATION((ps[(2) - (2)].val.i_tkval));
                            (yyval.opval) = newSTATEOP(0, NULL, (ps[(1) - (2)].val.opval), loc);
                            PL_parser->expect = XSTATE;
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),';');
                        ;}
    break;

  case 17:
#line 244 "perly.y"
    { (yyval.opval) = (OP*)NULL; ;}
    break;

  case 18:
#line 246 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 19:
#line 248 "perly.y"
    {
                            (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                            APPEND_MADPROPS_PV("modif", (yyval.opval), '>');
			;}
    break;

  case 20:
#line 254 "perly.y"
    { 
                            (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'i');
                            APPEND_MADPROPS_PV("modif", (yyval.opval), '>');
			;}
    break;

  case 21:
#line 260 "perly.y"
    {
                            (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval), FALSE, LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
			;}
    break;

  case 22:
#line 265 "perly.y"
    {
                            (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval), TRUE, LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
			;}
    break;

  case 23:
#line 270 "perly.y"
    { 
                            (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), FALSE, LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
			;}
    break;

  case 24:
#line 275 "perly.y"
    {
                            (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), TRUE, LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'w');
			;}
    break;

  case 25:
#line 280 "perly.y"
    { (yyval.opval) = newFOROP(0, NULL,
                                (OP*)NULL, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval), (OP*)NULL, LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),((LISTOP*)(yyval.opval))->op_first->op_sibling,'w');
			;}
    break;

  case 26:
#line 288 "perly.y"
    { (yyval.opval) = (OP*)NULL; ;}
    break;

  case 27:
#line 290 "perly.y"
    { ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS; (yyval.opval) = scope((ps[(2) - (2)].val.opval));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 28:
#line 294 "perly.y"
    { 
			    (yyval.opval) = newCONDOP(0, (ps[(3) - (6)].val.opval), scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval), LOCATION((ps[(1) - (6)].val.i_tkval)));
			    PL_hints |= HINT_BLOCK_SCOPE;
                            TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'I');
                            TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),')');
                            APPEND_MADPROPS_PV("if", (yyval.opval), '>');
			;}
    break;

  case 29:
#line 306 "perly.y"
    {
			    (yyval.opval) = block_end((ps[(3) - (7)].val.ionlyval),
                                newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval), LOCATION((ps[(1) - (7)].val.i_tkval))));
                            TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
                            TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
                            APPEND_MADPROPS_PV("if", (yyval.opval), '>');
			;}
    break;

  case 30:
#line 315 "perly.y"
    {
			    (yyval.opval) = block_end((ps[(3) - (7)].val.ionlyval),
                                newCONDOP(0, (ps[(4) - (7)].val.opval), scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval), LOCATION((ps[(1) - (7)].val.i_tkval))));
                            TOKEN_GETMAD((ps[(1) - (7)].val.i_tkval),(yyval.opval),'I');
                            TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),')');
                            APPEND_MADPROPS_PV("if", (yyval.opval), '>');
			;}
    break;

  case 31:
#line 327 "perly.y"
    {
                            (yyval.opval) = (OP*)NULL;
#ifdef PERL_MAD
                            if (PL_madskills) {
                                /* FIXME produces different results in "do" blocks */
                                (yyval.opval) = newOP(OP_NULL,0, NULL);
                                APPEND_MADPROPS_PV("value", (yyval.opval), '>');
                            }
#endif /* PERL_MAD */
                        ;}
    break;

  case 32:
#line 338 "perly.y"
    { (yyval.opval) = scope((ps[(2) - (2)].val.opval));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
    break;

  case 33:
#line 345 "perly.y"
    {
                            /* insert "defined $_ = " before "~< $fh" */
                            if ((ps[(5) - (6)].val.opval)->op_type == OP_READLINE) {
                                OP* mydef;
                                mydef = newOP(OP_PADSV, 0, NULL);
                                mydef->op_targ = allocmy("$_");
                                (yyval.opval) = newUNOP(OP_DEFINED, 0,
                                    newASSIGNOP(0, mydef,
                                        0, (ps[(5) - (6)].val.opval), (ps[(5) - (6)].val.opval)->op_location), (ps[(5) - (6)].val.opval)->op_location );
                            }
                            else {
                                (yyval.opval) = (ps[(5) - (6)].val.opval);
                            }
                        ;}
    break;

  case 34:
#line 360 "perly.y"
    {
                            OP *innerop;
			    (yyval.opval) = block_end((ps[(3) - (10)].val.ionlyval),
                                newSTATEOP(0, PVAL((ps[(1) - (10)].val.p_tkval)),
                                    innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                        LOCATION((ps[(2) - (10)].val.i_tkval)), (ps[(7) - (10)].val.opval), (ps[(9) - (10)].val.opval), (ps[(10) - (10)].val.opval), (ps[(8) - (10)].val.ionlyval)), LOCATION((ps[(2) - (10)].val.i_tkval))));
                            TOKEN_GETMAD((ps[(1) - (10)].val.p_tkval),innerop,'L');
                            TOKEN_GETMAD((ps[(2) - (10)].val.i_tkval),innerop,'W');
                            TOKEN_GETMAD((ps[(4) - (10)].val.i_tkval),innerop,'(');
                            TOKEN_GETMAD((ps[(6) - (10)].val.i_tkval),innerop,')');
			;}
    break;

  case 35:
#line 373 "perly.y"
    { 
                            OP *innerop;
			    (yyval.opval) = block_end((ps[(4) - (9)].val.ionlyval),
				   newSTATEOP(0, PVAL((ps[(1) - (9)].val.p_tkval)),
				     innerop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                         LOCATION((ps[(2) - (9)].val.i_tkval)), (ps[(5) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval), (ps[(7) - (9)].val.ionlyval)), LOCATION((ps[(2) - (9)].val.i_tkval))));
                            TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),innerop,'L');
                            TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),innerop,'W');
                            TOKEN_GETMAD((ps[(3) - (9)].val.i_tkval),innerop,'(');
                            TOKEN_GETMAD((ps[(6) - (9)].val.i_tkval),innerop,')');
			;}
    break;

  case 36:
#line 385 "perly.y"
    { OP *innerop;
			  (yyval.opval) = block_end((ps[(4) - (10)].val.ionlyval),
                              innerop = newFOROP(0, PVAL((ps[(1) - (10)].val.p_tkval)),
                                  (ps[(5) - (10)].val.opval), scalar((ps[(7) - (10)].val.opval)), (ps[(9) - (10)].val.opval), (ps[(10) - (10)].val.opval), LOCATION((ps[(2) - (10)].val.i_tkval))));
			  TOKEN_GETMAD((ps[(1) - (10)].val.p_tkval),((LISTOP*)innerop)->op_first->op_sibling,'L');
			  TOKEN_GETMAD((ps[(2) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
			  TOKEN_GETMAD((ps[(3) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'d');
			  TOKEN_GETMAD((ps[(6) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
			  TOKEN_GETMAD((ps[(8) - (10)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
			;}
    break;

  case 37:
#line 396 "perly.y"
    { OP *innerop;
			  (yyval.opval) = block_end((ps[(3) - (9)].val.ionlyval),
			     innerop = newFOROP(0, PVAL((ps[(1) - (9)].val.p_tkval)),
                                 (ps[(4) - (9)].val.opval), scalar((ps[(6) - (9)].val.opval)), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval), LOCATION((ps[(2) - (9)].val.i_tkval))));
			  TOKEN_GETMAD((ps[(1) - (9)].val.p_tkval),((LISTOP*)innerop)->op_first->op_sibling,'L');
			  TOKEN_GETMAD((ps[(2) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'W');
			  TOKEN_GETMAD((ps[(5) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,'(');
			  TOKEN_GETMAD((ps[(7) - (9)].val.i_tkval),((LISTOP*)innerop)->op_first->op_sibling,')');
			;}
    break;

  case 38:
#line 409 "perly.y"
    { (yyval.ionlyval) = (PL_min_intro_pending != -1 &&
			    PL_max_intro_pending >=  PL_min_intro_pending);
			  intro_my(); ;}
    break;

  case 39:
#line 415 "perly.y"
    { YYSTYPE tmplval;
			  (void)scan_num("1", &tmplval);
			  (yyval.opval) = tmplval.opval; ;}
    break;

  case 40:
#line 419 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 41:
#line 424 "perly.y"
    { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
    break;

  case 42:
#line 429 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
    break;

  case 43:
#line 433 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
    break;

  case 44:
#line 439 "perly.y"
    {
			  (yyval.p_tkval).pval = NULL;
#ifdef PERL_MAD
			  (yyval.p_tkval).madtoken = newMADTOKEN(OP_NULL, 0);
#endif
			  (yyval.p_tkval).pval = NULL;
			  (yyval.p_tkval).location = NULL;
			;}
    break;

  case 45:
#line 448 "perly.y"
    { (yyval.p_tkval) = (ps[(1) - (1)].val.p_tkval); ;}
    break;

  case 46:
#line 453 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 47:
#line 455 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 48:
#line 457 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 49:
#line 459 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 50:
#line 464 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 51:
#line 468 "perly.y"
    {
                            (yyval.opval) = newOP(OP_NULL,0, LOCATION((ps[(1) - (1)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'p');
                            APPEND_MADPROPS_PV("peg",(yyval.opval),'>');
			;}
    break;

  case 52:
#line 477 "perly.y"
    { 
#ifdef MAD
			  (yyval.opval) = newMYSUB((ps[(2) - (5)].val.ionlyval), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), NULL, (ps[(5) - (5)].val.opval));
			  TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'d');
#else
			  newMYSUB((ps[(2) - (5)].val.ionlyval), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), NULL, (ps[(5) - (5)].val.opval));
			  (yyval.opval) = (OP*)NULL;
#endif
			;}
    break;

  case 53:
#line 490 "perly.y"
    {
#ifdef MAD
                            CV* new;
                            (yyval.opval) = newOP(OP_NULL,0, LOCATION((ps[(1) - (5)].val.i_tkval)));
                            op_getmad((ps[(3) - (5)].val.opval),(yyval.opval),'n');
                            TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'d');
                            APPEND_MADPROPS_PV("sub", (yyval.opval), '<');
                            new = newNAMEDSUB((ps[(2) - (5)].val.ionlyval), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                            op_getmad(CvROOT(new),(yyval.opval),'&');
                            /* SvREFCNT_dec(new);  leak reference */
#else
                            CV* new = newNAMEDSUB((ps[(2) - (5)].val.ionlyval), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
                            CvREFCNT_dec(new);
                            (yyval.opval) = (OP*)NULL;
#endif
			;}
    break;

  case 54:
#line 507 "perly.y"
    {
#ifdef MAD
                            CV* new;
                            (yyval.opval) = newOP(OP_NULL,0, LOCATION((ps[(1) - (3)].val.i_tkval)));
                            op_getmad((ps[(3) - (3)].val.opval),(yyval.opval),'&');
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
                            APPEND_MADPROPS_PV("sub", (yyval.opval), '<');
                            new = newSUB((ps[(2) - (3)].val.ionlyval), NULL, (ps[(3) - (3)].val.opval));
                            SVcpREPLACE(SvLOCATION(cvTsv(new)), LOCATION((ps[(1) - (3)].val.i_tkval)));
                            process_special_block(IVAL((ps[(1) - (3)].val.i_tkval)), new);
                            /* SvREFCNT_dec(new);  leak reference */
#else
                            CV* new = cv_2mortal(newSUB((ps[(2) - (3)].val.ionlyval),
                                    newOP(OP_STUB, 0, LOCATION((ps[(1) - (3)].val.i_tkval))), (ps[(3) - (3)].val.opval)));
                            (ps[(2) - (3)].val.opval) = NULL;
                            (ps[(3) - (3)].val.opval) = NULL;
                            SVcpREPLACE(SvLOCATION(cvTsv(new)), LOCATION((ps[(1) - (3)].val.i_tkval)));
                            process_special_block(IVAL((ps[(1) - (3)].val.i_tkval)), new);
                            (yyval.opval) = (OP*)NULL;
#endif
                        ;}
    break;

  case 55:
#line 531 "perly.y"
    { (yyval.ionlyval) = start_subparse(0); 
                        ;}
    break;

  case 56:
#line 537 "perly.y"
    { (yyval.ionlyval) = start_subparse(CVf_ANON);
			;}
    break;

  case 57:
#line 542 "perly.y"
    { (yyval.ionlyval) = start_subparse(CVf_ANON|CVf_BLOCK);
			;}
    break;

  case 58:
#line 547 "perly.y"
    {
			  (yyval.opval) = (ps[(1) - (1)].val.opval);
                        ;}
    break;

  case 59:
#line 553 "perly.y"
    { 
                            CvFLAGS(PL_compcv) |= CVf_PROTO;
                            PL_parser->in_my = KEY_my;
                            (yyval.i_tkval) = (ps[(1) - (1)].val.i_tkval);
                        ;}
    break;

  case 60:
#line 561 "perly.y"
    { 
                            (yyval.i_tkval) = (ps[(1) - (1)].val.i_tkval);
                            PL_parser->in_my = FALSE;
                            PL_parser->expect = XBLOCK;
                        ;}
    break;

  case 61:
#line 569 "perly.y"
    { 
                            (yyval.opval) = NULL;
                        ;}
    break;

  case 62:
#line 573 "perly.y"
    { 
                            CvFLAGS(PL_compcv) |= CVf_ASSIGNARG;
                            (yyval.opval) = (ps[(2) - (2)].val.opval);
                        ;}
    break;

  case 63:
#line 580 "perly.y"
    { 
                            CvFLAGS(PL_compcv) |= CVf_OPTASSIGNARG;
                            (yyval.opval) = newOP(OP_PADSV, 0, LOCATION((ps[(1) - (2)].val.i_tkval)));
                            (yyval.opval)->op_targ = allocmy("$^is_assignment");
                        ;}
    break;

  case 64:
#line 588 "perly.y"
    { 
                            (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (1)].val.opval), NULL);
                        ;}
    break;

  case 65:
#line 592 "perly.y"
    { 
                            (yyval.opval) = prepend_elem(OP_LIST, (ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.opval));
                        ;}
    break;

  case 66:
#line 596 "perly.y"
    { 
                            (yyval.opval) = append_elem(OP_LIST, (ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.opval));
                        ;}
    break;

  case 67:
#line 600 "perly.y"
    { 
                            (yyval.opval) = prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(1) - (3)].val.opval));
                            (yyval.opval) = prepend_elem(OP_LIST, (ps[(3) - (3)].val.opval), (yyval.opval));
                        ;}
    break;

  case 68:
#line 608 "perly.y"
    {
                            pad_add_name("@_", NULL, FALSE);
                            CvFLAGS(PL_compcv) |= CVf_DEFARGS;
                            intro_my();
                            (yyval.opval) = (OP*)NULL; 
                        ;}
    break;

  case 69:
#line 615 "perly.y"
    { 
                            (yyval.opval) = (ps[(2) - (4)].val.opval);
                            if (! (yyval.opval))
                                (yyval.opval) = newOP(OP_STUB, 0, LOCATION((ps[(1) - (4)].val.i_tkval)) );

                            TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
                        ;}
    break;

  case 70:
#line 626 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 71:
#line 627 "perly.y"
    {
                           (yyval.opval) = newOP(OP_NULL, 0, LOCATION((ps[(1) - (1)].val.i_tkval)) );
                           yyerror("forward subroutine declartion not allowed");
                        ;}
    break;

  case 72:
#line 634 "perly.y"
    {
#ifdef MAD
			  (yyval.opval) = package((ps[(2) - (3)].val.opval));
			  TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
			  TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),';');
                          APPEND_MADPROPS_PV("package",(yyval.opval),'>');
#else
			  package((ps[(2) - (3)].val.opval));
			  (yyval.opval) = (OP*)NULL;
#endif
			;}
    break;

  case 73:
#line 648 "perly.y"
    { 
                            CV* cv;
#ifdef PERL_MAD
                            (yyval.opval) = utilize(IVAL((ps[(1) - (6)].val.i_tkval)), (ps[(2) - (6)].val.ionlyval), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval));
                            TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'o');
                            TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),';');
                            cv = svTcv(cSVOPx((yyval.opval))->op_sv);
#else
                            cv = utilize(IVAL((ps[(1) - (6)].val.i_tkval)), (ps[(2) - (6)].val.ionlyval), (ps[(3) - (6)].val.opval), (ps[(4) - (6)].val.opval), (ps[(5) - (6)].val.opval));
                            (yyval.opval) = (OP*)NULL;
#endif
                            (ps[(3) - (6)].val.opval) = NULL;
                            (ps[(4) - (6)].val.opval) = NULL;
                            (ps[(5) - (6)].val.opval) = NULL;
                            process_special_block(KEY_BEGIN, cv);
			;}
    break;

  case 74:
#line 668 "perly.y"
    {
                            (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                            APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 75:
#line 674 "perly.y"
    { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 76:
#line 679 "perly.y"
    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 77:
#line 684 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 78:
#line 688 "perly.y"
    { 
                            (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                            APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 79:
#line 694 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 80:
#line 699 "perly.y"
    {
#ifdef MAD
			  OP* op = newNULLLIST(NULL);
			  TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),op,',');
			  (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
                          APPEND_MADPROPS_PV(",", op, '>');
#else
			  (yyval.opval) = (ps[(1) - (2)].val.opval);
#endif
			;}
    break;

  case 81:
#line 710 "perly.y"
    { 
			  OP* term = (ps[(3) - (3)].val.opval);
			  DO_MAD(
			      term = newUNOP(OP_NULL, 0, term, LOCATION((ps[(2) - (3)].val.i_tkval)));
			      TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),term,',');
                              APPEND_MADPROPS_PV(",", term, '>');
			  )
			  (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
			;}
    break;

  case 82:
#line 720 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 83:
#line 725 "perly.y"
    { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
				append_elem(OP_LIST,
				    prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
				    newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval), (ps[(3) - (6)].val.opval)->op_location)),
                                (ps[(3) - (6)].val.opval)->op_location);
			  TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
			  TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),')');
                          APPEND_MADPROPS_PV("method", (yyval.opval), '>');
			;}
    break;

  case 84:
#line 736 "perly.y"
    { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
				append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
				    newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval), (ps[(3) - (3)].val.opval)->op_location)), (ps[(3) - (3)].val.opval)->op_location);
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
                          APPEND_MADPROPS_PV("method", (yyval.opval), '>');
			;}
    break;

  case 85:
#line 743 "perly.y"
    {
                            (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                            APPEND_MADPROPS_PV("listop", (yyval.opval), '>');
			;}
    break;

  case 86:
#line 749 "perly.y"
    {
                            (yyval.opval) = newANONHASH((ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'{');
			;}
    break;

  case 87:
#line 754 "perly.y"
    {
                            (yyval.opval) = newANONARRAY((ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
			;}
    break;

  case 88:
#line 759 "perly.y"
    {
                            (yyval.opval) = newUNOP(OP_ANONSCALAR, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
			;}
    break;

  case 89:
#line 764 "perly.y"
    { 
                            (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval), LOCATION((ps[(1) - (4)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
                            TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
                            APPEND_MADPROPS_PV("func", (yyval.opval), '>');
			;}
    break;

  case 90:
#line 775 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 91:
#line 777 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 92:
#line 784 "perly.y"
    {
                            (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)), (ps[(1) - (5)].val.opval)->op_location);
			    PL_parser->expect = XOPERATOR;
			  TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
			  TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
			  TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 93:
#line 792 "perly.y"
    {
                            (yyval.opval) = newAVREF((ps[(1) - (2)].val.opval), LOCATION((ps[(2) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'a');
                        ;}
    break;

  case 94:
#line 797 "perly.y"
    {
                            (yyval.opval) = newSVREF((ps[(1) - (2)].val.opval), LOCATION((ps[(2) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'a');
                        ;}
    break;

  case 95:
#line 802 "perly.y"
    {
                            (yyval.opval) = newHVREF((ps[(1) - (2)].val.opval), LOCATION((ps[(2) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'a');
                        ;}
    break;

  case 96:
#line 807 "perly.y"
    {
                            (yyval.opval) = newGVREF(0, (ps[(1) - (2)].val.opval), LOCATION((ps[(2) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'a');
                        ;}
    break;

  case 97:
#line 812 "perly.y"
    {
                            (yyval.opval) = newCVREF(0, (ps[(1) - (2)].val.opval), LOCATION((ps[(2) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'a');
                        ;}
    break;

  case 98:
#line 817 "perly.y"
    { 
                            (yyval.opval) = newBINOP(OP_AELEM, 0, scalar((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)), LOCATION((ps[(2) - (4)].val.i_tkval)));
                            (yyval.opval)->op_private = IVAL((ps[(2) - (4)].val.i_tkval));
                            TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
                            TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
			;}
    break;

  case 99:
#line 824 "perly.y"
    {
                            (yyval.opval) = newBINOP(OP_AELEM, 0,
                                ref(newAVREF((ps[(1) - (5)].val.opval), LOCATION((ps[(2) - (5)].val.i_tkval))),OP_RV2AV),
                                scalar((ps[(4) - (5)].val.opval)), LOCATION((ps[(3) - (5)].val.i_tkval)));
                            (yyval.opval)->op_private = IVAL((ps[(3) - (5)].val.i_tkval));
                            TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
                            TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
                            TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
			;}
    break;

  case 100:
#line 834 "perly.y"
    { (yyval.opval) = newLISTOP(OP_HSLICE, 0,
                                    scalar((ps[(4) - (7)].val.opval)),
                                    ref(newHVREF((ps[(1) - (7)].val.opval), LOCATION((ps[(2) - (7)].val.i_tkval))), OP_HSLICE), LOCATION((ps[(3) - (7)].val.i_tkval)));
			    PL_parser->expect = XOPERATOR;
			  TOKEN_GETMAD((ps[(2) - (7)].val.i_tkval),(yyval.opval),'a');
			  TOKEN_GETMAD((ps[(3) - (7)].val.i_tkval),(yyval.opval),'{');
			  TOKEN_GETMAD((ps[(5) - (7)].val.i_tkval),(yyval.opval),'j');
			  TOKEN_GETMAD((ps[(6) - (7)].val.i_tkval),(yyval.opval),';');
			  TOKEN_GETMAD((ps[(7) - (7)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 101:
#line 845 "perly.y"
    { (yyval.opval) = newLISTOP(OP_ASLICE, 0,
					scalar((ps[(4) - (6)].val.opval)),
					ref(newAVREF((ps[(1) - (6)].val.opval), LOCATION((ps[(2) - (6)].val.i_tkval))), OP_ASLICE), LOCATION((ps[(3) - (6)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
			  TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'[');
			  TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),'j');
			  TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),']');
			;}
    break;

  case 102:
#line 854 "perly.y"
    { (yyval.opval) = newLISTOP(OP_HSLICE, 0,
					scalar((ps[(3) - (6)].val.opval)),
					ref((ps[(1) - (6)].val.opval), OP_HSLICE), LOCATION((ps[(2) - (6)].val.i_tkval)));
			    PL_parser->expect = XOPERATOR;
			  TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'{');
			  TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'j');
			  TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
			  TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 103:
#line 864 "perly.y"
    { (yyval.opval) = newLISTOP(OP_ASLICE, 0,
					scalar((ps[(3) - (5)].val.opval)),
					ref((ps[(1) - (5)].val.opval), OP_ASLICE), LOCATION((ps[(2) - (5)].val.i_tkval)));
			    PL_parser->expect = XOPERATOR;
			  TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'[');
			  TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),'j');
			  TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
			;}
    break;

  case 104:
#line 873 "perly.y"
    { 
                            (yyval.opval) = newBINOP(OP_HELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)),
                                LOCATION((ps[(2) - (5)].val.i_tkval)));
                            (yyval.opval)->op_private = IVAL((ps[(2) - (5)].val.i_tkval));
                            if ((yyval.opval)->op_private & OPpELEM_ADD) {
                                (yyval.opval) = op_mod_assign((yyval.opval), &(cBINOPx((yyval.opval))->op_first), OP_HELEM);
                            }
			    PL_parser->expect = XOPERATOR;
                            TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
                            TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 105:
#line 886 "perly.y"
    {
                            (yyval.opval) = newBINOP(OP_HELEM, 0,
                                ref(newHVREF((ps[(1) - (6)].val.opval), LOCATION((ps[(2) - (6)].val.i_tkval))),OP_RV2HV),
                                scalar((ps[(4) - (6)].val.opval)), LOCATION((ps[(3) - (6)].val.i_tkval)));
                            (yyval.opval)->op_private = IVAL((ps[(3) - (6)].val.i_tkval));
			    PL_parser->expect = XOPERATOR;
                            TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
                            TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
                            TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 106:
#line 898 "perly.y"
    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                                newCVREF(0, scalar((ps[(1) - (4)].val.opval)), LOCATION((ps[(2) - (4)].val.i_tkval))), LOCATION((ps[(2) - (4)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
			  TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 107:
#line 905 "perly.y"
    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
				   append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
				       newCVREF(0, scalar((ps[(1) - (5)].val.opval)), LOCATION((ps[(2) - (5)].val.i_tkval)))), LOCATION((ps[(2) - (5)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
			  TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 108:
#line 916 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 109:
#line 921 "perly.y"
    {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
				scalar((ps[(1) - (3)].val.opval));
			    (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 110:
#line 928 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 111:
#line 933 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 112:
#line 938 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 113:
#line 943 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 114:
#line 948 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 115:
#line 953 "perly.y"
    { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 116:
#line 958 "perly.y"
    {
                            (yyval.opval) = newBINOP(OP_RANGE, 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)), LOCATION((ps[(2) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                            APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 117:
#line 964 "perly.y"
    { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 118:
#line 969 "perly.y"
    { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 119:
#line 974 "perly.y"
    { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval), LOCATION((ps[(2) - (3)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 120:
#line 979 "perly.y"
    { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
				((yyval.opval)->op_type == OP_NOT
				    ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
				'~');
                          APPEND_MADPROPS_PV("bind_match",
				((yyval.opval)->op_type == OP_NOT
				    ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
                                             '>');
			;}
    break;

  case 121:
#line 993 "perly.y"
    { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 122:
#line 997 "perly.y"
    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 123:
#line 1001 "perly.y"
    { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 124:
#line 1005 "perly.y"
    { (yyval.opval) = newUNOP(OP_EXPAND, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 125:
#line 1009 "perly.y"
    { (yyval.opval) = newUNOP(OP_ARRAYEXPAND, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 126:
#line 1013 "perly.y"
    { (yyval.opval) = newUNOP(OP_HASHEXPAND, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                        ;}
    break;

  case 127:
#line 1017 "perly.y"
    { (yyval.opval) = newUNOP(OP_POSTINC, 0,
                                scalar((ps[(1) - (2)].val.opval)), LOCATION((ps[(2) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 128:
#line 1022 "perly.y"
    { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
                                mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC), LOCATION((ps[(2) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 129:
#line 1027 "perly.y"
    { (yyval.opval) = newUNOP(OP_PREINC, 0,
                                mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 130:
#line 1032 "perly.y"
    { (yyval.opval) = newUNOP(OP_PREDEC, 0,
                                mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 131:
#line 1042 "perly.y"
    {
                            (yyval.opval) = newANONSUB((ps[(2) - (3)].val.ionlyval), NULL, scalar((ps[(3) - (3)].val.opval)));
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 132:
#line 1047 "perly.y"
    {
                            (yyval.opval) = newANONSUB((ps[(2) - (4)].val.ionlyval), (ps[(3) - (4)].val.opval), scalar((ps[(4) - (4)].val.opval)));
                            TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 133:
#line 1055 "perly.y"
    { 
                            (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 134:
#line 1060 "perly.y"
    {
                            OP* op_scope =
                                scope(newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                        LOCATION((ps[(1) - (3)].val.i_tkval)), (OP*)NULL, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval), 0));
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),op_scope,'o');
                            (yyval.opval) = newSTATEOP(0, NULL, op_scope,
                                LOCATION((ps[(1) - (3)].val.i_tkval)));
                            (yyval.opval) = scope((yyval.opval));
                        ;}
    break;

  case 135:
#line 1070 "perly.y"
    {
                            OP* op_scope = 
                                scope(newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
                                        LOCATION((ps[(2) - (4)].val.i_tkval)), (OP*)NULL, (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval), 0));
                            TOKEN_GETMAD((ps[(1) - (4)].val.p_tkval),op_scope,'L');
                            TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),op_scope,'o');
                            (yyval.opval) = newSTATEOP(0, PVAL((ps[(1) - (4)].val.p_tkval)), op_scope, LOCATION((ps[(2) - (4)].val.i_tkval)));
                            /* $$ = scope($$); should work */
			;}
    break;

  case 136:
#line 1082 "perly.y"
    { 
                            (yyval.opval) = (ps[(2) - (2)].val.opval);
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'H');
                            (yyval.opval)->op_flags |= OPf_OPTIONAL;
                        ;}
    break;

  case 137:
#line 1088 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 138:
#line 1090 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 139:
#line 1092 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 140:
#line 1094 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 141:
#line 1096 "perly.y"
    { 
                            (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval), LOCATION((ps[(2) - (5)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
                            TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
                            APPEND_MADPROPS_PV("?",(yyval.opval),'>');
			;}
    break;

  case 142:
#line 1103 "perly.y"
    { (yyval.opval) = newUNOP(OP_SREFGEN, 0, mod(scalar((ps[(2) - (2)].val.opval)),OP_SREFGEN), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("operator",(yyval.opval),'>');
			;}
    break;

  case 143:
#line 1108 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 144:
#line 1110 "perly.y"
    { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
			;}
    break;

  case 145:
#line 1114 "perly.y"
    {
                            (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval), LOCATION((ps[(1) - (3)].val.i_tkval))), (ps[(2) - (3)].val.opval)));
                            APPEND_MADPROPS_PV("(", (yyval.opval), '>');
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 146:
#line 1121 "perly.y"
    {
                            (yyval.opval) = sawparens(newNULLLIST(LOCATION((ps[(1) - (2)].val.i_tkval))));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 147:
#line 1127 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 148:
#line 1129 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 149:
#line 1131 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 150:
#line 1133 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 151:
#line 1135 "perly.y"
    {
                            (yyval.opval) = (ps[(1) - (1)].val.opval);
                            (yyval.opval)->op_flags |= OPf_SPECIAL;
                        ;}
    break;

  case 152:
#line 1140 "perly.y"
    {
                            (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)), (ps[(1) - (3)].val.opval)->op_location);
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
                          APPEND_MADPROPS_PV("amper", (yyval.opval), '>');
			;}
    break;

  case 153:
#line 1147 "perly.y"
    {
			  (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
				append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))), (ps[(1) - (4)].val.opval)->op_location);
			  DO_MAD({
			      OP* op = (yyval.opval);
			      if (op->op_type == OP_CONST) { /* defeat const fold */
				op = (OP*)op->op_madprop->mad_val;
			      }
			      TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),op,'(');
			      TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),op,')');
                              APPEND_MADPROPS_PV("amper", (yyval.opval), '>');
			  })
			;}
    break;

  case 154:
#line 1161 "perly.y"
    { 
                          (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
                              append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))), (ps[(2) - (3)].val.opval)->op_location);
			  TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("noamp", (yyval.opval), '>');
			;}
    break;

  case 155:
#line 1168 "perly.y"
    {
                            (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL, LOCATION((ps[(1) - (1)].val.i_tkval)));
			    PL_hints |= HINT_BLOCK_SCOPE;
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 156:
#line 1174 "perly.y"
    { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 157:
#line 1178 "perly.y"
    { (yyval.opval) = newUNOP(OP_RETURN, OPf_STACKED, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 158:
#line 1182 "perly.y"
    { (yyval.opval) = newOP(OP_RETURN, 0, LOCATION((ps[(1) - (1)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 159:
#line 1186 "perly.y"
    { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 160:
#line 1190 "perly.y"
    { 
                            (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0, LOCATION((ps[(1) - (1)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
                            APPEND_MADPROPS_PV("uniop", (yyval.opval), '>');
			;}
    break;

  case 161:
#line 1196 "perly.y"
    { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                          APPEND_MADPROPS_PV("uniop", (yyval.opval), '>');
			;}
    break;

  case 162:
#line 1201 "perly.y"
    {
                            (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
                            APPEND_MADPROPS_PV("uniop", (yyval.opval), '>');
			;}
    break;

  case 163:
#line 1207 "perly.y"
    {
                            (yyval.opval) = newOP(OP_REQUIRE, IVAL((ps[(1) - (1)].val.i_tkval)) ? OPf_SPECIAL : 0, LOCATION((ps[(1) - (1)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 164:
#line 1212 "perly.y"
    { (yyval.opval) = newUNOP(OP_REQUIRE, IVAL((ps[(1) - (2)].val.i_tkval)) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 165:
#line 1216 "perly.y"
    { 
                            (yyval.opval) = newBINOP(OP_COMPSUB, 0, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.opval)->op_location);
			;}
    break;

  case 166:
#line 1220 "perly.y"
    { 
                            (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)->op_location); 
                            APPEND_MADPROPS_PV("uniop", (yyval.opval), '>');
                        ;}
    break;

  case 167:
#line 1225 "perly.y"
    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
			    append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval))), (ps[(1) - (2)].val.opval)->op_location);
                          APPEND_MADPROPS_PV("uniop", (yyval.opval), '>');
                        ;}
    break;

  case 168:
#line 1230 "perly.y"
    { 
                            (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0, LOCATION((ps[(1) - (1)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
			;}
    break;

  case 169:
#line 1235 "perly.y"
    {
                            (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, LOCATION((ps[(1) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
                            TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 170:
#line 1242 "perly.y"
    { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
				scalar((ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)->op_location); ;}
    break;

  case 171:
#line 1245 "perly.y"
    { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
                                ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0), LOCATION((ps[(1) - (3)].val.i_tkval))), LOCATION((ps[(1) - (3)].val.i_tkval)))
                                : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL, LOCATION((ps[(1) - (3)].val.i_tkval)));

			  TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
			  TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
                          APPEND_MADPROPS_PV("func1", (yyval.opval), '>');
			;}
    break;

  case 172:
#line 1255 "perly.y"
    { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval), LOCATION((ps[(1) - (4)].val.i_tkval)));
			  TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
			  TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
                          APPEND_MADPROPS_PV("func1", (yyval.opval), '>');
			;}
    break;

  case 173:
#line 1262 "perly.y"
    { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
			  TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 174:
#line 1267 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 175:
#line 1269 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 176:
#line 1274 "perly.y"
    { 
                            (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
			;}
    break;

  case 177:
#line 1282 "perly.y"
    { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
			  TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
			  TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 178:
#line 1287 "perly.y"
    {
                            (yyval.opval) = sawparens(newNULLLIST(LOCATION((ps[(1) - (2)].val.i_tkval))));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
			;}
    break;

  case 179:
#line 1293 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 180:
#line 1297 "perly.y"
    { 
                            (yyval.opval) = newOP(OP_PADSV, 0, NULL);
                            (yyval.opval)->op_targ = allocmy("$_");
                        ;}
    break;

  case 181:
#line 1304 "perly.y"
    { (yyval.opval) = (OP*)NULL; ;}
    break;

  case 182:
#line 1306 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 183:
#line 1310 "perly.y"
    { (yyval.opval) = (OP*)NULL; ;}
    break;

  case 184:
#line 1312 "perly.y"
    { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
    break;

  case 185:
#line 1314 "perly.y"
    {
#ifdef MAD
			  OP* op = newNULLLIST(NULL);
			  TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),op,',');
			  (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
                          APPEND_MADPROPS_PV(",", op, '>');
#else
			  (yyval.opval) = (ps[(1) - (2)].val.opval);
#endif

			;}
    break;

  case 186:
#line 1330 "perly.y"
    { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
    break;

  case 187:
#line 1334 "perly.y"
    { 
                            (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
			;}
    break;

  case 188:
#line 1342 "perly.y"
    { 
                            (yyval.opval) = newPRIVATEVAROP(PL_parser->tokenbuf, LOCATION((ps[(1) - (1)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'X');
                        ;}
    break;

  case 189:
#line 1347 "perly.y"
    { 
                            (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
			;}
    break;

  case 190:
#line 1352 "perly.y"
    { 
                            (yyval.opval) = newUNOP(OP_ANONSCALAR, 0, scalar((ps[(2) - (3)].val.opval)), LOCATION((ps[(1) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
                            TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');

                            if (PL_parser->lex_brackets <= 0)
                                yyerror("Unmatched right paren");
                            else
                                --PL_parser->lex_brackets;

                            if (PL_parser->lex_state == LEX_INTERPNORMAL) {
                                if ( PL_parser->lex_brackets == 0 )
                                    PL_parser->lex_state = LEX_INTERPEND;
                            }
			;}
    break;

  case 191:
#line 1368 "perly.y"
    { 
                            (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
			;}
    break;

  case 192:
#line 1373 "perly.y"
    {
                            (yyval.opval) = newANONARRAY((ps[(2) - (3)].val.opval), LOCATION((ps[(1) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
                            TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
			;}
    break;

  case 193:
#line 1379 "perly.y"
    {
                            (yyval.opval) = newANONARRAY((OP*)NULL, LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
			;}
    break;

  case 194:
#line 1385 "perly.y"
    {
                            (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
			;}
    break;

  case 195:
#line 1390 "perly.y"
    { 
                            (yyval.opval) = newANONHASH((ps[(2) - (3)].val.opval), LOCATION((ps[(1) - (3)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 196:
#line 1396 "perly.y"
    { 
                            (yyval.opval) = newANONHASH((OP*)NULL, LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'{');
                            TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'}');
			;}
    break;

  case 197:
#line 1404 "perly.y"
    {
                            (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval), LOCATION((ps[(1) - (2)].val.i_tkval)));
                            TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
			;}
    break;

  case 198:
#line 1412 "perly.y"
    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
    break;

  case 199:
#line 1414 "perly.y"
    { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
    break;

  case 200:
#line 1416 "perly.y"
    { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
    break;



      default: break;