File Coverage

blib/lib/Treex/Core/ScenarioParser.pm

Criterion	Covered	Total	%
statement	2162	3849	56.1
branch	635	2278	27.8
condition	169	831	20.3
subroutine	143	291	49.1
pod	0	1	0.0
total	3109	7250	42.8

## no critic (Miscellanea::ProhibitUnrestrictedNoCritic)
## no critic Generated code follows
{
# GENERATE RECURSIVE DESCENT PARSER OBJECTS FROM A GRAMMAR

use 5.006;
use strict;

package Parse::RecDescent::_Runtime;
$Parse::RecDescent::_Runtime::VERSION = '2.20150928';
use Text::Balanced qw ( extract_codeblock extract_bracketed extract_quotelike extract_delimited );

use vars qw ( $skip );

   *defskip  = \ '\s*'; # DEFAULT SEPARATOR IS OPTIONAL WHITESPACE
   $skip  = '\s*';      # UNIVERSAL SEPARATOR IS OPTIONAL WHITESPACE
my $MAXREP  = 100_000_000;  # REPETITIONS MATCH AT MOST 100,000,000 TIMES



package Parse::RecDescent::_Runtime::LineCounter;
$Parse::RecDescent::_Runtime::LineCounter::VERSION = '2.20150928';

sub TIESCALAR   # ($classname, \$text, $thisparser, $prevflag)
{
    bless {
        text    => $_[1],
        parser  => $_[2],
        prev    => $_[3]?1:0,
          }, $_[0];
}

sub FETCH
{
    my $parser = $_[0]->{parser};
    my $cache = $parser->{linecounter_cache};
    my $from = $parser->{fulltextlen}-length(${$_[0]->{text}})-$_[0]->{prev}
;

    unless (exists $cache->{$from})
    {
        $parser->{lastlinenum} = $parser->{offsetlinenum}
          - Parse::RecDescent::_Runtime::_linecount(substr($parser->{fulltext},$from))
          + 1;
        $cache->{$from} = $parser->{lastlinenum};
    }
    return $cache->{$from};
}

sub STORE
{
    my $parser = $_[0]->{parser};
    $parser->{offsetlinenum} -= $parser->{lastlinenum} - $_[1];
    return undef;
}

sub resync   # ($linecounter)
{
    my $self = tied($_[0]);
    die "Tried to alter something other than a LineCounter\n"
        unless $self =~ /Parse::RecDescent::_Runtime::LineCounter/;

    my $parser = $self->{parser};
    my $apparently = $parser->{offsetlinenum}
             - Parse::RecDescent::_Runtime::_linecount(${$self->{text}})
             + 1;

    $parser->{offsetlinenum} += $parser->{lastlinenum} - $apparently;
    return 1;
}

package Parse::RecDescent::_Runtime::ColCounter;
$Parse::RecDescent::_Runtime::ColCounter::VERSION = '2.20150928';
sub TIESCALAR   # ($classname, \$text, $thisparser, $prevflag)
{
    bless {
        text    => $_[1],
        parser  => $_[2],
        prev    => $_[3]?1:0,
          }, $_[0];
}

sub FETCH
{
    my $parser = $_[0]->{parser};
    my $missing = $parser->{fulltextlen}-length(${$_[0]->{text}})-$_[0]->{prev}+1;
    substr($parser->{fulltext},0,$missing) =~ m/^(.*)\Z/m;
    return length($1);
}

sub STORE
{
    die "Can't set column number via \$thiscolumn\n";
}


package Parse::RecDescent::_Runtime::OffsetCounter;
$Parse::RecDescent::_Runtime::OffsetCounter::VERSION = '2.20150928';
sub TIESCALAR   # ($classname, \$text, $thisparser, $prev)
{
    bless {
        text    => $_[1],
        parser  => $_[2],
        prev    => $_[3]?-1:0,
          }, $_[0];
}

sub FETCH
{
    my $parser = $_[0]->{parser};
    return $parser->{fulltextlen}-length(${$_[0]->{text}})+$_[0]->{prev};
}

sub STORE
{
    die "Can't set current offset via \$thisoffset or \$prevoffset\n";
}



package Parse::RecDescent::_Runtime::Rule;
$Parse::RecDescent::_Runtime::Rule::VERSION = '2.20150928';
sub new ($$$$$)
{
    my $class = ref($_[0]) || $_[0];
    my $name  = $_[1];
    my $owner = $_[2];
    my $line  = $_[3];
    my $replace = $_[4];

    if (defined $owner->{"rules"}{$name})
    {
        my $self = $owner->{"rules"}{$name};
        if ($replace && !$self->{"changed"})
        {
            $self->reset;
        }
        return $self;
    }
    else
    {
        return $owner->{"rules"}{$name} =
            bless
            {
                "name"     => $name,
                "prods"    => [],
                "calls"    => [],
                "changed"  => 0,
                "line"     => $line,
                "impcount" => 0,
                "opcount"  => 0,
                "vars"     => "",
            }, $class;
    }
}

sub reset($)
{
    @{$_[0]->{"prods"}} = ();
    @{$_[0]->{"calls"}} = ();
    $_[0]->{"changed"}  = 0;
    $_[0]->{"impcount"}  = 0;
    $_[0]->{"opcount"}  = 0;
    $_[0]->{"vars"}  = "";
}

sub DESTROY {}

sub hasleftmost($$)
{
    my ($self, $ref) = @_;

    my $prod;
    foreach $prod ( @{$self->{"prods"}} )
    {
        return 1 if $prod->hasleftmost($ref);
    }

    return 0;
}

sub leftmostsubrules($)
{
    my $self = shift;
    my @subrules = ();

    my $prod;
    foreach $prod ( @{$self->{"prods"}} )
    {
        push @subrules, $prod->leftmostsubrule();
    }

    return @subrules;
}

sub expected($)
{
    my $self = shift;
    my @expected = ();

    my $prod;
    foreach $prod ( @{$self->{"prods"}} )
    {
        my $next = $prod->expected();
        unless (! $next or _contains($next,@expected) )
        {
            push @expected, $next;
        }
    }

    return join ', or ', @expected;
}

sub _contains($@)
{
    my $target = shift;
    my $item;
    foreach $item ( @_ ) { return 1 if $target eq $item; }
    return 0;
}

sub addcall($$)
{
    my ( $self, $subrule ) = @_;
    unless ( _contains($subrule, @{$self->{"calls"}}) )
    {
        push @{$self->{"calls"}}, $subrule;
    }
}

sub addprod($$)
{
    my ( $self, $prod ) = @_;
    push @{$self->{"prods"}}, $prod;
    $self->{"changed"} = 1;
    $self->{"impcount"} = 0;
    $self->{"opcount"} = 0;
    $prod->{"number"} = $#{$self->{"prods"}};
    return $prod;
}

sub addvar
{
    my ( $self, $var, $parser ) = @_;
    if ($var =~ /\A\s*local\s+([%@\$]\w+)/)
    {
        $parser->{localvars} .= " $1";
        $self->{"vars"} .= "$var;\n" }
    else
        { $self->{"vars"} .= "my $var;\n" }
    $self->{"changed"} = 1;
    return 1;
}

sub addautoscore
{
    my ( $self, $code ) = @_;
    $self->{"autoscore"} = $code;
    $self->{"changed"} = 1;
    return 1;
}

sub nextoperator($)
{
    my $self = shift;
    my $prodcount = scalar @{$self->{"prods"}};
    my $opcount = ++$self->{"opcount"};
    return "_operator_${opcount}_of_production_${prodcount}_of_rule_$self->{name}";
}

sub nextimplicit($)
{
    my $self = shift;
    my $prodcount = scalar @{$self->{"prods"}};
    my $impcount = ++$self->{"impcount"};
    return "_alternation_${impcount}_of_production_${prodcount}_of_rule_$self->{name}";
}


sub code
{
    my ($self, $namespace, $parser, $check) = @_;

eval 'undef &' . $namespace . '::' . $self->{"name"} unless $parser->{saving};

    my $code =
'
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub ' . $namespace . '::' . $self->{"name"} .  '
{
		my $thisparser = $_[0];
		use vars q{$tracelevel};
		local $tracelevel = ($tracelevel||0)+1;
		$ERRORS = 0;
        my $thisrule = $thisparser->{"rules"}{"' . $self->{"name"} . '"};

        Parse::RecDescent::_Runtime::_trace(q{Trying rule: [' . $self->{"name"} . ']},
                                    Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                                    q{' . $self->{"name"} . '},
                                    $tracelevel)
                                        if defined $::RD_TRACE;

        ' . ($parser->{deferrable}
        ? 'my $def_at = @{$thisparser->{deferred}};'
        : '') .
    '
        my $err_at = @{$thisparser->{errors}};

        my $score;
        my $score_return;
        my $_tok;
        my $return = undef;
        my $_matched=0;
        my $commit=0;
        my @item = ();
        my %item = ();
        my $repeating =  $_[2];
        my $_noactions = $_[3];
        my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
        my $_itempos = $_[5];
        my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
        my $text;
        my $lastsep;
        my $current_match;
        my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{' . $self->expected() . '});
        $expectation->at($_[1]);
        '. ($parser->{_check}{thisoffset}?'
        my $thisoffset;
        tie $thisoffset, q{Parse::RecDescent::_Runtime::OffsetCounter}, \$text, $thisparser;
        ':'') . ($parser->{_check}{prevoffset}?'
        my $prevoffset;
        tie $prevoffset, q{Parse::RecDescent::_Runtime::OffsetCounter}, \$text, $thisparser, 1;
        ':'') . ($parser->{_check}{thiscolumn}?'
        my $thiscolumn;
        tie $thiscolumn, q{Parse::RecDescent::_Runtime::ColCounter}, \$text, $thisparser;
        ':'') . ($parser->{_check}{prevcolumn}?'
        my $prevcolumn;
        tie $prevcolumn, q{Parse::RecDescent::_Runtime::ColCounter}, \$text, $thisparser, 1;
        ':'') . ($parser->{_check}{prevline}?'
        my $prevline;
        tie $prevline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser, 1;
        ':'') . '
        my $thisline;
        tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;

        '. $self->{vars} .'
';

    my $prod;
    foreach $prod ( @{$self->{"prods"}} )
    {
        $prod->addscore($self->{autoscore},0,0) if $self->{autoscore};
        next unless $prod->checkleftmost();
        $code .= $prod->code($namespace,$self,$parser);

        $code .= $parser->{deferrable}
                ? '     splice
                                @{$thisparser->{deferred}}, $def_at unless $_matched;
                                    '
                : '';
    }

    $code .=
'
        unless ( $_matched || defined($score) )
        {
                ' .($parser->{deferrable}
            ? '     splice @{$thisparser->{deferred}}, $def_at;
                            '
            : '') . '

                $_[1] = $text;  # NOT SURE THIS IS NEEDED
                Parse::RecDescent::_Runtime::_trace(q{<<'.Parse::RecDescent::_Runtime::_matchtracemessage($self,1).' rule>>},
                                          Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                                          q{' . $self->{"name"} .'},
                                          $tracelevel)
                                        if defined $::RD_TRACE;
                return undef;
        }
        if (!defined($return) && defined($score))
        {
                Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                                            q{' . $self->{"name"} .'},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                $return = $score_return;
        }
        splice @{$thisparser->{errors}}, $err_at;
        $return = $item[$#item] unless defined $return;
        if (defined $::RD_TRACE)
        {
                Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' rule<< (return value: [} .
                                            $return . q{])}, "",
                                            q{' . $self->{"name"} .'},
                                            $tracelevel);
                Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                                            Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            , q{' . $self->{"name"} .'},
                                            $tracelevel)
        }
        $_[1] = $text;
        return $return;
}
';

    return $code;
}

my @left;
sub isleftrec($$)
{
    my ($self, $rules) = @_;
    my $root = $self->{"name"};
    @left = $self->leftmostsubrules();
    my $next;
    foreach $next ( @left )
    {
        next unless defined $rules->{$next}; # SKIP NON-EXISTENT RULES
        return 1 if $next eq $root;
        my $child;
        foreach $child ( $rules->{$next}->leftmostsubrules() )
        {
            push(@left, $child)
            if ! _contains($child, @left) ;
        }
    }
    return 0;
}

package Parse::RecDescent::_Runtime::Production;
$Parse::RecDescent::_Runtime::Production::VERSION = '2.20150928';
sub describe ($;$)
{
    return join ' ', map { $_->describe($_[1]) or () } @{$_[0]->{items}};
}

sub new ($$;$$)
{
    my ($self, $line, $uncommit, $error) = @_;
    my $class = ref($self) || $self;

    bless
    {
        "items"    => [],
        "uncommit" => $uncommit,
        "error"    => $error,
        "line"     => $line,
        strcount   => 0,
        patcount   => 0,
        dircount   => 0,
        actcount   => 0,
    }, $class;
}

sub expected ($)
{
    my $itemcount = scalar @{$_[0]->{"items"}};
    return ($itemcount) ? $_[0]->{"items"}[0]->describe(1) : '';
}

sub hasleftmost ($$)
{
    my ($self, $ref) = @_;
    return ${$self->{"items"}}[0] eq $ref  if scalar @{$self->{"items"}};
    return 0;
}

sub isempty($)
{
    my $self = shift;
    return 0 == @{$self->{"items"}};
}

sub leftmostsubrule($)
{
    my $self = shift;

    if ( $#{$self->{"items"}} >= 0 )
    {
        my $subrule = $self->{"items"}[0]->issubrule();
        return $subrule if defined $subrule;
    }

    return ();
}

sub checkleftmost($)
{
    my @items = @{$_[0]->{"items"}};
    if (@items==1 && ref($items[0]) =~ /\AParse::RecDescent::_Runtime::Error/
        && $items[0]->{commitonly} )
    {
        Parse::RecDescent::_Runtime::_warn(2,"Lone <error?> in production treated
                                                as <error?> <reject>");
        Parse::RecDescent::_Runtime::_hint("A production consisting of a single
                                            conditional <error?> directive would
                                            normally succeed (with the value zero) if the
                                            rule is not 'commited' when it is
                                            tried. Since you almost certainly wanted
                                            '<error?> <reject>' Parse::RecDescent::_Runtime
                                            supplied it for you.");
        push @{$_[0]->{items}},
            Parse::RecDescent::_Runtime::UncondReject->new(0,0,'<reject>');
    }
    elsif (@items==1 && ($items[0]->describe||"") =~ /<rulevar|<autoscore/)
    {
        # Do nothing
    }
    elsif (@items &&
        ( ref($items[0]) =~ /\AParse::RecDescent::_Runtime::UncondReject/
        || ($items[0]->describe||"") =~ /<autoscore/
        ))
    {
        Parse::RecDescent::_Runtime::_warn(1,"Optimizing away production: [". $_[0]->describe ."]");
        my $what = $items[0]->describe =~ /<rulevar/
                ? "a <rulevar> (which acts like an unconditional <reject> during parsing)"
             : $items[0]->describe =~ /<autoscore/
                ? "an <autoscore> (which acts like an unconditional <reject> during parsing)"
                : "an unconditional <reject>";
        my $caveat = $items[0]->describe =~ /<rulevar/
                ? " after the specified variable was set up"
                : "";
        my $advice = @items > 1
                ? "However, there were also other (useless) items after the leading "
                  . $items[0]->describe
                  . ", so you may have been expecting some other behaviour."
                : "You can safely ignore this message.";
        Parse::RecDescent::_Runtime::_hint("The production starts with $what. That means that the
                                            production can never successfully match, so it was
                                            optimized out of the final parser$caveat. $advice");
        return 0;
    }
    return 1;
}

sub changesskip($)
{
    my $item;
    foreach $item (@{$_[0]->{"items"}})
    {
        if (ref($item) =~ /Parse::RecDescent::_Runtime::(Action|Directive)/)
        {
            return 1 if $item->{code} =~ /\$skip\s*=/;
        }
    }
    return 0;
}

sub adddirective
{
    my ( $self, $whichop, $line, $name ) = @_;
    push @{$self->{op}},
        { type=>$whichop, line=>$line, name=>$name,
          offset=> scalar(@{$self->{items}}) };
}

sub addscore
{
    my ( $self, $code, $lookahead, $line ) = @_;
    $self->additem(Parse::RecDescent::_Runtime::Directive->new(
                  "local \$^W;
                                      my \$thisscore = do { $code } + 0;
                                      if (!defined(\$score) || \$thisscore>\$score)
                                        { \$score=\$thisscore; \$score_return=\$item[-1]; }
                                      undef;", $lookahead, $line,"<score: $code>") )
        unless $self->{items}[-1]->describe =~ /<score/;
    return 1;
}

sub check_pending
{
    my ( $self, $line ) = @_;
    if ($self->{op})
    {
        while (my $next = pop @{$self->{op}})
        {
        Parse::RecDescent::_Runtime::_error("Incomplete <$next->{type}op:...>.", $line);
        Parse::RecDescent::_Runtime::_hint(
            "The current production ended without completing the
                          <$next->{type}op:...> directive that started near line
                          $next->{line}. Did you forget the closing '>'?");
        }
    }
    return 1;
}

sub enddirective
{
    my ( $self, $line, $minrep, $maxrep ) = @_;
    unless ($self->{op})
    {
        Parse::RecDescent::_Runtime::_error("Unmatched > found.", $line);
        Parse::RecDescent::_Runtime::_hint(
            "A '>' angle bracket was encountered, which typically
                          indicates the end of a directive. However no suitable
                          preceding directive was encountered. Typically this
                          indicates either a extra '>' in the grammar, or a
                          problem inside the previous directive.");
        return;
    }
    my $op = pop @{$self->{op}};
    my $span = @{$self->{items}} - $op->{offset};
    if ($op->{type} =~ /left|right/)
    {
        if ($span != 3)
        {
        Parse::RecDescent::_Runtime::_error(
            "Incorrect <$op->{type}op:...> specification:
                          expected 3 args, but found $span instead", $line);
        Parse::RecDescent::_Runtime::_hint(
            "The <$op->{type}op:...> directive requires a
                          sequence of exactly three elements. For example:
                          <$op->{type}op:leftarg /op/ rightarg>");
        }
        else
        {
        push @{$self->{items}},
            Parse::RecDescent::_Runtime::Operator->new(
                $op->{type}, $minrep, $maxrep, splice(@{$self->{"items"}}, -3));
        $self->{items}[-1]->sethashname($self);
        $self->{items}[-1]{name} = $op->{name};
        }
    }
}

sub prevwasreturn
{
    my ( $self, $line ) = @_;
    unless (@{$self->{items}})
    {
        Parse::RecDescent::_Runtime::_error(
            "Incorrect <return:...> specification:
                        expected item missing", $line);
        Parse::RecDescent::_Runtime::_hint(
            "The <return:...> directive requires a
                        sequence of at least one item. For example:
                        <return: list>");
        return;
    }
    push @{$self->{items}},
        Parse::RecDescent::_Runtime::Result->new();
}

sub additem
{
    my ( $self, $item ) = @_;
    $item->sethashname($self);
    push @{$self->{"items"}}, $item;
    return $item;
}

sub _duplicate_itempos
{
    my ($src) = @_;
    my $dst = {};

    foreach (keys %$src)
    {
        %{$dst->{$_}} = %{$src->{$_}};
    }
    $dst;
}

sub _update_itempos
{
    my ($dst, $src, $typekeys, $poskeys) = @_;

    my @typekeys = 'ARRAY' eq ref $typekeys ?
      @$typekeys :
      keys %$src;

    foreach my $k (keys %$src)
    {
        if ('ARRAY' eq ref $poskeys)
        {
            @{$dst->{$k}}{@$poskeys} = @{$src->{$k}}{@$poskeys};
        }
        else
        {
            %{$dst->{$k}} = %{$src->{$k}};
        }
    }
}

sub preitempos
{
    return q
        {
                push @itempos, {'offset' => {'from'=>$thisoffset, 'to'=>undef},
                                                'line'   => {'from'=>$thisline,   'to'=>undef},
                                                'column' => {'from'=>$thiscolumn, 'to'=>undef} };
        }
}

sub incitempos
{
    return q
        {
                $itempos[$#itempos]{'offset'}{'from'} += length($lastsep);
                $itempos[$#itempos]{'line'}{'from'}   = $thisline;
                $itempos[$#itempos]{'column'}{'from'} = $thiscolumn;
        }
}

sub unincitempos
{
    # the next incitempos will properly set these two fields, but
    # {'offset'}{'from'} needs to be decreased by length($lastsep)
    # $itempos[$#itempos]{'line'}{'from'}
    # $itempos[$#itempos]{'column'}{'from'}
    return q
        {
                $itempos[$#itempos]{'offset'}{'from'} -= length($lastsep) if defined $lastsep;
        }
}

sub postitempos
{
    return q
        {
                $itempos[$#itempos]{'offset'}{'to'} = $prevoffset;
                $itempos[$#itempos]{'line'}{'to'}   = $prevline;
                $itempos[$#itempos]{'column'}{'to'} = $prevcolumn;
        }
}

sub code($$$$)
{
    my ($self,$namespace,$rule,$parser) = @_;
    my $code =
'
        while (!$_matched'
    . (defined $self->{"uncommit"} ? '' : ' && !$commit')
    . ')
        {
                ' .
        ($self->changesskip()
            ? 'local $skip = defined($skip) ? $skip : $Parse::RecDescent::_Runtime::skip;'
            : '') .'
                Parse::RecDescent::_Runtime::_trace(q{Trying production: ['
                      . $self->describe . ']},
                                            Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                                            q{' . $rule ->{name}. '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                my $thisprod = $thisrule->{"prods"}[' . $self->{"number"} . '];
                ' . (defined $self->{"error"} ? '' : '$text = $_[1];' ) . '
                my $_savetext;
                @item = (q{' . $rule->{"name"} . '});
                %item = (__RULE__ => q{' . $rule->{"name"} . '});
                my $repcount = 0;

';
    $code .=
'        my @itempos = ({});
'           if $parser->{_check}{itempos};

    my $item;
    my $i;

    for ($i = 0; $i < @{$self->{"items"}}; $i++)
    {
        $item = ${$self->{items}}[$i];

        $code .= preitempos() if $parser->{_check}{itempos};

        $code .= $item->code($namespace,$rule,$parser->{_check});

        $code .= postitempos() if $parser->{_check}{itempos};

    }

    if ($parser->{_AUTOACTION} && defined($item) && !$item->isa("Parse::RecDescent::_Runtime::Action"))
    {
        $code .= $parser->{_AUTOACTION}->code($namespace,$rule);
        Parse::RecDescent::_Runtime::_warn(1,"Autogenerating action in rule
                                              \"$rule->{name}\":
                                                $parser->{_AUTOACTION}{code}")
        and
        Parse::RecDescent::_Runtime::_hint("The \$::RD_AUTOACTION was defined,
                                            so any production not ending in an
                                            explicit action has the specified
                                            \"auto-action\" automatically
                                            appended.");
    }
    elsif ($parser->{_AUTOTREE} && defined($item) && !$item->isa("Parse::RecDescent::_Runtime::Action"))
    {
        if ($i==1 && $item->isterminal)
        {
            $code .= $parser->{_AUTOTREE}{TERMINAL}->code($namespace,$rule);
        }
        else
        {
            $code .= $parser->{_AUTOTREE}{NODE}->code($namespace,$rule);
        }
        Parse::RecDescent::_Runtime::_warn(1,"Autogenerating tree-building action in rule
                                              \"$rule->{name}\"")
        and
        Parse::RecDescent::_Runtime::_hint("The directive <autotree> was specified,
                                            so any production not ending
                                            in an explicit action has
                                            some parse-tree building code
                                            automatically appended.");
    }

    $code .=
'
                Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' production: ['
                      . $self->describe . ']<<},
                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;

' . ( $parser->{_check}{itempos} ? '
                if ( defined($_itempos) )
                {
                        Parse::RecDescent::_Runtime::Production::_update_itempos($_itempos, $itempos[ 1], undef, [qw(from)]);
                        Parse::RecDescent::_Runtime::Production::_update_itempos($_itempos, $itempos[-1], undef, [qw(to)]);
                }
' : '' ) . '

                $_matched = 1;
                last;
        }

';
    return $code;
}

1;

package Parse::RecDescent::_Runtime::Action;
$Parse::RecDescent::_Runtime::Action::VERSION = '2.20150928';
sub describe { undef }

sub sethashname { $_[0]->{hashname} = '__ACTION' . ++$_[1]->{actcount} .'__'; }

sub new
{
    my $class = ref($_[0]) || $_[0];
    bless
    {
        "code"      => $_[1],
        "lookahead" => $_[2],
        "line"      => $_[3],
    }, $class;
}

sub issubrule { undef }
sub isterminal { 0 }

sub code($$$$)
{
    my ($self, $namespace, $rule) = @_;

'
                Parse::RecDescent::_Runtime::_trace(q{Trying action},
                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'

                $_tok = ($_noactions) ? 0 : do ' . $self->{"code"} . ';
                ' . ($self->{"lookahead"}<0?'if':'unless') . ' (defined $_tok)
                {
                        Parse::RecDescent::_Runtime::_trace(q{<<'.Parse::RecDescent::_Runtime::_matchtracemessage($self,1).' action>> (return value: [undef])})
                                        if defined $::RD_TRACE;
                        last;
                }
                Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' action<< (return value: [}
                                            . $_tok . q{])},
                                            Parse::RecDescent::_Runtime::_tracefirst($text))
                                                if defined $::RD_TRACE;
                push @item, $_tok;
                ' . ($self->{line}>=0 ? '$item{'. $self->{hashname} .'}=$_tok;' : '' ) .'
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
'
}


1;

package Parse::RecDescent::_Runtime::Directive;
$Parse::RecDescent::_Runtime::Directive::VERSION = '2.20150928';
sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} .  '__'; }

sub issubrule { undef }
sub isterminal { 0 }
sub describe { $_[1] ? '' : $_[0]->{name} }

sub new ($$$$$)
{
    my $class = ref($_[0]) || $_[0];
    bless
    {
        "code"      => $_[1],
        "lookahead" => $_[2],
        "line"      => $_[3],
        "name"      => $_[4],
    }, $class;
}

sub code($$$$)
{
    my ($self, $namespace, $rule) = @_;

'
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'

                Parse::RecDescent::_Runtime::_trace(q{Trying directive: ['
                    . $self->describe . ']},
                                        Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE; ' .'
                $_tok = do { ' . $self->{"code"} . ' };
                if (defined($_tok))
                {
                        Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' directive<< (return value: [}
                                                . $_tok . q{])},
                                                Parse::RecDescent::_Runtime::_tracefirst($text))
                                                        if defined $::RD_TRACE;
                }
                else
                {
                        Parse::RecDescent::_Runtime::_trace(q{<<'.Parse::RecDescent::_Runtime::_matchtracemessage($self,1).' directive>>},
                                                Parse::RecDescent::_Runtime::_tracefirst($text))
                                                        if defined $::RD_TRACE;
                }
                ' . ($self->{"lookahead"} ? '$text = $_savetext and ' : '' ) .'
                last '
        . ($self->{"lookahead"}<0?'if':'unless') . ' defined $_tok;
                push @item, $item{'.$self->{hashname}.'}=$_tok;
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
'
}

1;

package Parse::RecDescent::_Runtime::UncondReject;
$Parse::RecDescent::_Runtime::UncondReject::VERSION = '2.20150928';
sub issubrule { undef }
sub isterminal { 0 }
sub describe { $_[1] ? '' : $_[0]->{name} }
sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} .  '__'; }

sub new ($$$;$)
{
    my $class = ref($_[0]) || $_[0];
    bless
    {
        "lookahead" => $_[1],
        "line"      => $_[2],
        "name"      => $_[3],
    }, $class;
}

# MARK, YOU MAY WANT TO OPTIMIZE THIS.


sub code($$$$)
{
    my ($self, $namespace, $rule) = @_;

'
                Parse::RecDescent::_Runtime::_trace(q{>>Rejecting production<< (found '
                     . $self->describe . ')},
                                          Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                undef $return;
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'

                $_tok = undef;
                ' . ($self->{"lookahead"} ? '$text = $_savetext and ' : '' ) .'
                last '
        . ($self->{"lookahead"}<0?'if':'unless') . ' defined $_tok;
'
}

1;

package Parse::RecDescent::_Runtime::Error;
$Parse::RecDescent::_Runtime::Error::VERSION = '2.20150928';
sub issubrule { undef }
sub isterminal { 0 }
sub describe { $_[1] ? '' : $_[0]->{commitonly} ? '<error?:...>' : '<error...>' }
sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} .  '__'; }

sub new ($$$$$)
{
    my $class = ref($_[0]) || $_[0];
    bless
    {
        "msg"        => $_[1],
        "lookahead"  => $_[2],
        "commitonly" => $_[3],
        "line"       => $_[4],
    }, $class;
}

sub code($$$$)
{
    my ($self, $namespace, $rule) = @_;

    my $action = '';

    if ($self->{"msg"})  # ERROR MESSAGE SUPPLIED
    {
        #WAS: $action .= "Parse::RecDescent::_Runtime::_error(qq{$self->{msg}}" .  ',$thisline);';
        $action .= 'push @{$thisparser->{errors}}, [qq{'.$self->{msg}.'},$thisline];';

    }
    else      # GENERATE ERROR MESSAGE DURING PARSE
    {
        $action .= '
                my $rule = $item[0];
                      $rule =~ s/_/ /g;
                #WAS: Parse::RecDescent::_Runtime::_error("Invalid $rule: " . $expectation->message() ,$thisline);
                push @{$thisparser->{errors}}, ["Invalid $rule: " . $expectation->message() ,$thisline];
                ';
    }

    my $dir =
          new Parse::RecDescent::_Runtime::Directive('if (' .
        ($self->{"commitonly"} ? '$commit' : '1') .
        ") { do {$action} unless ".' $_noactions; undef } else {0}',
                    $self->{"lookahead"},0,$self->describe);
    $dir->{hashname} = $self->{hashname};
    return $dir->code($namespace, $rule, 0);
}

1;

package Parse::RecDescent::_Runtime::Token;
$Parse::RecDescent::_Runtime::Token::VERSION = '2.20150928';
sub sethashname { $_[0]->{hashname} = '__PATTERN' . ++$_[1]->{patcount} . '__'; }

sub issubrule { undef }
sub isterminal { 1 }
sub describe ($) { shift->{'description'}}


# ARGS ARE: $self, $pattern, $left_delim, $modifiers, $lookahead, $linenum
sub new ($$$$$$)
{
    my $class = ref($_[0]) || $_[0];
    my $pattern = $_[1];
    my $pat = $_[1];
    my $ldel = $_[2];
    my $rdel = $ldel;
    $rdel =~ tr/{[(</}])>/;

    my $mod = $_[3];

    my $desc;

    if ($ldel eq '/') { $desc = "$ldel$pattern$rdel$mod" }
    else          { $desc = "m$ldel$pattern$rdel$mod" }
    $desc =~ s/\\/\\\\/g;
    $desc =~ s/\$$/\\\$/g;
    $desc =~ s/}/\\}/g;
    $desc =~ s/{/\\{/g;

    if (!eval "no strict;
                      local \$SIG{__WARN__} = sub {0};
                      '' =~ m$ldel$pattern$rdel$mod" and $@)
    {
        Parse::RecDescent::_Runtime::_warn(3, "Token pattern \"m$ldel$pattern$rdel$mod\"
                                                  may not be a valid regular expression",
                       $_[5]);
        $@ =~ s/ at \(eval.*/./;
        Parse::RecDescent::_Runtime::_hint($@);
    }

    # QUIETLY PREVENT (WELL-INTENTIONED) CALAMITY
    $mod =~ s/[gc]//g;
    $pattern =~ s/(\A|[^\\])\\G/$1/g;

    bless
    {
        "pattern"   => $pattern,
        "ldelim"      => $ldel,
        "rdelim"      => $rdel,
        "mod"         => $mod,
        "lookahead"   => $_[4],
        "line"        => $_[5],
        "description" => $desc,
    }, $class;
}


sub code($$$$$)
{
    my ($self, $namespace, $rule, $check) = @_;
    my $ldel = $self->{"ldelim"};
    my $rdel = $self->{"rdelim"};
    my $sdel = $ldel;
    my $mod  = $self->{"mod"};

    $sdel =~ s/[[{(<]/{}/;

my $code = '
                Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [' . $self->describe
                      . ']}, Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                undef $lastsep;
                $expectation->is(q{' . ($rule->hasleftmost($self) ? ''
                : $self->describe ) . '})->at($text);
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) . '

                ' . ($self->{"lookahead"}<0?'if':'unless')
        . ' ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and '
        . ($check->{itempos}? 'do {'.Parse::RecDescent::_Runtime::Production::incitempos().' 1} and ' : '')
        . '  $text =~ m' . $ldel . '\A(?:' . $self->{"pattern"} . ')' . $rdel . $mod . ')
                {
                        '.($self->{"lookahead"} ? '$text = $_savetext;' : '$text = $lastsep . $text if defined $lastsep;') .
            ($check->{itempos} ? Parse::RecDescent::_Runtime::Production::unincitempos() : '') . '
                        $expectation->failed();
                        Parse::RecDescent::_Runtime::_trace(q{<<Didn\'t match terminal>>},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text))
                                        if defined $::RD_TRACE;

                        last;
                }
                $current_match = substr($text, $-[0], $+[0] - $-[0]);
                substr($text,0,length($current_match),q{});
                Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                                                . $current_match . q{])},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text))
                                        if defined $::RD_TRACE;
                push @item, $item{'.$self->{hashname}.'}=$current_match;
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
';

    return $code;
}

1;

package Parse::RecDescent::_Runtime::Literal;
$Parse::RecDescent::_Runtime::Literal::VERSION = '2.20150928';
sub sethashname { $_[0]->{hashname} = '__STRING' . ++$_[1]->{strcount} . '__'; }

sub issubrule { undef }
sub isterminal { 1 }
sub describe ($) { shift->{'description'} }

sub new ($$$$)
{
    my $class = ref($_[0]) || $_[0];

    my $pattern = $_[1];

    my $desc = $pattern;
    $desc=~s/\\/\\\\/g;
    $desc=~s/}/\\}/g;
    $desc=~s/{/\\{/g;

    bless
    {
        "pattern"     => $pattern,
        "lookahead"   => $_[2],
        "line"        => $_[3],
        "description" => "'$desc'",
    }, $class;
}


sub code($$$$)
{
    my ($self, $namespace, $rule, $check) = @_;

my $code = '
                Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [' . $self->describe
                      . ']},
                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                undef $lastsep;
                $expectation->is(q{' . ($rule->hasleftmost($self) ? ''
                : $self->describe ) . '})->at($text);
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) . '

                ' . ($self->{"lookahead"}<0?'if':'unless')
        . ' ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and '
        . ($check->{itempos}? 'do {'.Parse::RecDescent::_Runtime::Production::incitempos().' 1} and ' : '')
        . '  $text =~ m/\A' . quotemeta($self->{"pattern"}) . '/)
                {
                        '.($self->{"lookahead"} ? '$text = $_savetext;' : '$text = $lastsep . $text if defined $lastsep;').'
                        '. ($check->{itempos} ? Parse::RecDescent::_Runtime::Production::unincitempos() : '') . '
                        $expectation->failed();
                        Parse::RecDescent::_Runtime::_trace(qq{<<Didn\'t match terminal>>},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text))
                                                        if defined $::RD_TRACE;
                        last;
                }
                $current_match = substr($text, $-[0], $+[0] - $-[0]);
                substr($text,0,length($current_match),q{});
                Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                                                . $current_match . q{])},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text))
                                                        if defined $::RD_TRACE;
                push @item, $item{'.$self->{hashname}.'}=$current_match;
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
';

    return $code;
}

1;

package Parse::RecDescent::_Runtime::InterpLit;
$Parse::RecDescent::_Runtime::InterpLit::VERSION = '2.20150928';
sub sethashname { $_[0]->{hashname} = '__STRING' . ++$_[1]->{strcount} . '__'; }

sub issubrule { undef }
sub isterminal { 1 }
sub describe ($) { shift->{'description'} }

sub new ($$$$)
{
    my $class = ref($_[0]) || $_[0];

    my $pattern = $_[1];
    $pattern =~ s#/#\\/#g;

    my $desc = $pattern;
    $desc=~s/\\/\\\\/g;
    $desc=~s/}/\\}/g;
    $desc=~s/{/\\{/g;

    bless
    {
        "pattern"   => $pattern,
        "lookahead" => $_[2],
        "line"      => $_[3],
        "description" => "'$desc'",
    }, $class;
}

sub code($$$$)
{
    my ($self, $namespace, $rule, $check) = @_;

my $code = '
                Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [' . $self->describe
                      . ']},
                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{name} . '},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                undef $lastsep;
                $expectation->is(q{' . ($rule->hasleftmost($self) ? ''
                : $self->describe ) . '})->at($text);
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) . '

                ' . ($self->{"lookahead"}<0?'if':'unless')
        . ' ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and '
        . ($check->{itempos}? 'do {'.Parse::RecDescent::_Runtime::Production::incitempos().' 1} and ' : '')
        . '  do { $_tok = "' . $self->{"pattern"} . '"; 1 } and
                          substr($text,0,length($_tok)) eq $_tok and
                          do { substr($text,0,length($_tok)) = ""; 1; }
                )
                {
                        '.($self->{"lookahead"} ? '$text = $_savetext;' : '$text = $lastsep . $text if defined $lastsep;').'
                        '. ($check->{itempos} ? Parse::RecDescent::_Runtime::Production::unincitempos() : '') . '
                        $expectation->failed();
                        Parse::RecDescent::_Runtime::_trace(q{<<Didn\'t match terminal>>},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text))
                                                        if defined $::RD_TRACE;
                        last;
                }
                Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                                                . $_tok . q{])},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text))
                                                        if defined $::RD_TRACE;
                push @item, $item{'.$self->{hashname}.'}=$_tok;
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
';

    return $code;
}

1;

package Parse::RecDescent::_Runtime::Subrule;
$Parse::RecDescent::_Runtime::Subrule::VERSION = '2.20150928';
sub issubrule ($) { return $_[0]->{"subrule"} }
sub isterminal { 0 }
sub sethashname {}

sub describe ($)
{
    my $desc = $_[0]->{"implicit"} || $_[0]->{"subrule"};
    $desc = "<matchrule:$desc>" if $_[0]->{"matchrule"};
    return $desc;
}

sub callsyntax($$)
{
    if ($_[0]->{"matchrule"})
    {
        return "&{'$_[1]'.qq{$_[0]->{subrule}}}";
    }
    else
    {
        return $_[1].$_[0]->{"subrule"};
    }
}

sub new ($$$$;$$$)
{
    my $class = ref($_[0]) || $_[0];
    bless
    {
        "subrule"   => $_[1],
        "lookahead" => $_[2],
        "line"      => $_[3],
        "implicit"  => $_[4] || undef,
        "matchrule" => $_[5],
        "argcode"   => $_[6] || undef,
    }, $class;
}


sub code($$$$)
{
    my ($self, $namespace, $rule, $check) = @_;

'
                Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [' . $self->{"subrule"} . ']},
                                    Parse::RecDescent::_Runtime::_tracefirst($text),
                                    q{' . $rule->{"name"} . '},
                                    $tracelevel)
                                        if defined $::RD_TRACE;
                if (1) { no strict qw{refs};
                $expectation->is(' . ($rule->hasleftmost($self) ? 'q{}'
                # WAS : 'qq{'.$self->describe.'}' ) . ')->at($text);
                : 'q{'.$self->describe.'}' ) . ')->at($text);
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' )
        . ($self->{"lookahead"}<0?'if':'unless')
        . ' (defined ($_tok = '
        . $self->callsyntax($namespace.'::')
        . '($thisparser,$text,$repeating,'
        . ($self->{"lookahead"}?'1':'$_noactions')
        . ($self->{argcode} ? ",sub { return $self->{argcode} }"
                   : ',sub { \\@arg }')
        . ($check->{"itempos"}?',$itempos[$#itempos]':',undef')
        . ')))
                {
                        '.($self->{"lookahead"} ? '$text = $_savetext;' : '').'
                        Parse::RecDescent::_Runtime::_trace(q{<<'.Parse::RecDescent::_Runtime::_matchtracemessage($self,1).' subrule: ['
            . $self->{subrule} . ']>>},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text),
                                                    q{' . $rule->{"name"} .'},
                                                    $tracelevel)
                                                        if defined $::RD_TRACE;
                        $expectation->failed();
                        last;
                }
                Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' subrule: ['
                    . $self->{subrule} . ']<< (return value: [}
                                        . $_tok . q{]},

                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{"name"} .'},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                $item{q{' . $self->{subrule} . '}} = $_tok;
                push @item, $_tok;
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'
                }
'
}

package Parse::RecDescent::_Runtime::Repetition;
$Parse::RecDescent::_Runtime::Repetition::VERSION = '2.20150928';
sub issubrule ($) { return $_[0]->{"subrule"} }
sub isterminal { 0 }
sub sethashname {  }

sub describe ($)
{
    my $desc = $_[0]->{"expected"} || $_[0]->{"subrule"};
    $desc = "<matchrule:$desc>" if $_[0]->{"matchrule"};
    return $desc;
}

sub callsyntax($$)
{
    if ($_[0]->{matchrule})
        { return "sub { goto &{''.qq{$_[1]$_[0]->{subrule}}} }"; }
    else
        { return "\\&$_[1]$_[0]->{subrule}"; }
}

sub new ($$$$$$$$$$)
{
    my ($self, $subrule, $repspec, $min, $max, $lookahead, $line, $parser, $matchrule, $argcode) = @_;
    my $class = ref($self) || $self;
    ($max, $min) = ( $min, $max) if ($max<$min);

    my $desc;
    if ($subrule=~/\A_alternation_\d+_of_production_\d+_of_rule/)
        { $desc = $parser->{"rules"}{$subrule}->expected }

    if ($lookahead)
    {
        if ($min>0)
        {
           return new Parse::RecDescent::_Runtime::Subrule($subrule,$lookahead,$line,$desc,$matchrule,$argcode);
        }
        else
        {
            Parse::RecDescent::_Runtime::_error("Not symbol (\"!\") before
                                                \"$subrule\" doesn't make
                                                sense.",$line);
            Parse::RecDescent::_Runtime::_hint("Lookahead for negated optional
                                              repetitions (such as
                                              \"!$subrule($repspec)\" can never
                                              succeed, since optional items always
                                              match (zero times at worst).
                                              Did you mean a single \"!$subrule\",
                                              instead?");
        }
    }
    bless
    {
        "subrule"   => $subrule,
        "repspec"   => $repspec,
        "min"       => $min,
        "max"       => $max,
        "lookahead" => $lookahead,
        "line"      => $line,
        "expected"  => $desc,
        "argcode"   => $argcode || undef,
        "matchrule" => $matchrule,
    }, $class;
}

sub code($$$$)
{
    my ($self, $namespace, $rule, $check) = @_;

    my ($subrule, $repspec, $min, $max, $lookahead) =
        @{$self}{ qw{subrule repspec min max lookahead} };

'
                Parse::RecDescent::_Runtime::_trace(q{Trying repeated subrule: [' . $self->describe . ']},
                                    Parse::RecDescent::_Runtime::_tracefirst($text),
                                    q{' . $rule->{"name"} . '},
                                    $tracelevel)
                                        if defined $::RD_TRACE;
                $expectation->is(' . ($rule->hasleftmost($self) ? 'q{}'
                # WAS : 'qq{'.$self->describe.'}' ) . ')->at($text);
                : 'q{'.$self->describe.'}' ) . ')->at($text);
                ' . ($self->{"lookahead"} ? '$_savetext = $text;' : '' ) .'
                unless (defined ($_tok = $thisparser->_parserepeat($text, '
        . $self->callsyntax($namespace.'::')
        . ', ' . $min . ', ' . $max . ', '
        . ($self->{"lookahead"}?'1':'$_noactions')
        . ',$expectation,'
        . ($self->{argcode} ? "sub { return $self->{argcode} }"
                        : 'sub { \\@arg }')
        . ($check->{"itempos"}?',$itempos[$#itempos]':',undef')
        . ')))
                {
                        Parse::RecDescent::_Runtime::_trace(q{<<'.Parse::RecDescent::_Runtime::_matchtracemessage($self,1).' repeated subrule: ['
            . $self->describe . ']>>},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text),
                                                    q{' . $rule->{"name"} .'},
                                                    $tracelevel)
                                                        if defined $::RD_TRACE;
                        last;
                }
                Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' repeated subrule: ['
                    . $self->{subrule} . ']<< (}
                                        . @$_tok . q{ times)},

                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{"name"} .'},
                                            $tracelevel)
                                                if defined $::RD_TRACE;
                $item{q{' . "$self->{subrule}($self->{repspec})" . '}} = $_tok;
                push @item, $_tok;
                ' . ($self->{"lookahead"} ? '$text = $_savetext;' : '' ) .'

'
}

package Parse::RecDescent::_Runtime::Result;
$Parse::RecDescent::_Runtime::Result::VERSION = '2.20150928';
sub issubrule { 0 }
sub isterminal { 0 }
sub describe { '' }

sub new
{
    my ($class, $pos) = @_;

    bless {}, $class;
}

sub code($$$$)
{
    my ($self, $namespace, $rule) = @_;

    '
                $return = $item[-1];
        ';
}

package Parse::RecDescent::_Runtime::Operator;
$Parse::RecDescent::_Runtime::Operator::VERSION = '2.20150928';
my @opertype = ( " non-optional", "n optional" );

sub issubrule { 0 }
sub isterminal { 0 }

sub describe { $_[0]->{"expected"} }
sub sethashname { $_[0]->{hashname} = '__DIRECTIVE' . ++$_[1]->{dircount} .  '__'; }


sub new
{
    my ($class, $type, $minrep, $maxrep, $leftarg, $op, $rightarg) = @_;

    bless
    {
        "type"      => "${type}op",
        "leftarg"   => $leftarg,
        "op"        => $op,
        "min"       => $minrep,
        "max"       => $maxrep,
        "rightarg"  => $rightarg,
        "expected"  => "<${type}op: ".$leftarg->describe." ".$op->describe." ".$rightarg->describe.">",
    }, $class;
}

sub code($$$$)
{
    my ($self, $namespace, $rule, $check) = @_;

    my @codeargs = @_[1..$#_];

    my ($leftarg, $op, $rightarg) =
        @{$self}{ qw{leftarg op rightarg} };

    my $code = '
                Parse::RecDescent::_Runtime::_trace(q{Trying operator: [' . $self->describe . ']},
                                    Parse::RecDescent::_Runtime::_tracefirst($text),
                                    q{' . $rule->{"name"} . '},
                                    $tracelevel)
                                        if defined $::RD_TRACE;
                $expectation->is(' . ($rule->hasleftmost($self) ? 'q{}'
                # WAS : 'qq{'.$self->describe.'}' ) . ')->at($text);
                : 'q{'.$self->describe.'}' ) . ')->at($text);

                $_tok = undef;
                OPLOOP: while (1)
                {
                    $repcount = 0;
                    my @item;
                    my %item;
';

    $code .= '
                    my  $_itempos = $itempos[-1];
                    my  $itemposfirst;
' if $check->{itempos};

    if ($self->{type} eq "leftop" )
    {
        $code .= '
                    # MATCH LEFTARG
                    ' . $leftarg->code(@codeargs) . '

';

        $code .= '
                    if (defined($_itempos) and !defined($itemposfirst))
                    {
                            $itemposfirst = Parse::RecDescent::_Runtime::Production::_duplicate_itempos($_itempos);
                    }
' if $check->{itempos};

        $code .= '
                    $repcount++;

                    my $savetext = $text;
                    my $backtrack;

                    # MATCH (OP RIGHTARG)(s)
                    while ($repcount < ' . $self->{max} . ')
                    {
                        $backtrack = 0;
                        ' . $op->code(@codeargs) . '
                        ' . ($op->isterminal() ? 'pop @item;' : '$backtrack=1;' ) . '
                        ' . (ref($op) eq 'Parse::RecDescent::_Runtime::Token'
                ? 'if (defined $1) {push @item, $item{'.($self->{name}||$self->{hashname}).'}=$1; $backtrack=1;}'
                : "" ) . '
                        ' . $rightarg->code(@codeargs) . '
                        $savetext = $text;
                        $repcount++;
                    }
                    $text = $savetext;
                    pop @item if $backtrack;

                    ';
    }
    else
    {
        $code .= '
                    my $savetext = $text;
                    my $backtrack;
                    # MATCH (LEFTARG OP)(s)
                    while ($repcount < ' . $self->{max} . ')
                    {
                        $backtrack = 0;
                        ' . $leftarg->code(@codeargs) . '
';
        $code .= '
                        if (defined($_itempos) and !defined($itemposfirst))
                        {
                                $itemposfirst = Parse::RecDescent::_Runtime::Production::_duplicate_itempos($_itempos);
                        }
' if $check->{itempos};

        $code .= '
                        $repcount++;
                        $backtrack = 1;
                        ' . $op->code(@codeargs) . '
                        $savetext = $text;
                        ' . ($op->isterminal() ? 'pop @item;' : "" ) . '
                        ' . (ref($op) eq 'Parse::RecDescent::_Runtime::Token' ? 'do { push @item, $item{'.($self->{name}||$self->{hashname}).'}=$1; } if defined $1;' : "" ) . '
                    }
                    $text = $savetext;
                    pop @item if $backtrack;

                    # MATCH RIGHTARG
                    ' . $rightarg->code(@codeargs) . '
                    $repcount++;
                    ';
    }

    $code .= 'unless (@item) { undef $_tok; last }' unless $self->{min}==0;

    $code .= '
                    $_tok = [ @item ];
';


    $code .= '
                    if (defined $itemposfirst)
                    {
                            Parse::RecDescent::_Runtime::Production::_update_itempos(
                                    $_itempos, $itemposfirst, undef, [qw(from)]);
                    }
' if $check->{itempos};

    $code .= '
                    last;
                } # end of OPLOOP
';

    $code .= '
                unless ($repcount>='.$self->{min}.')
                {
                        Parse::RecDescent::_Runtime::_trace(q{<<'.Parse::RecDescent::_Runtime::_matchtracemessage($self,1).' operator: ['
                          . $self->describe
                          . ']>>},
                                                    Parse::RecDescent::_Runtime::_tracefirst($text),
                                                    q{' . $rule->{"name"} .'},
                                                    $tracelevel)
                                                        if defined $::RD_TRACE;
                        $expectation->failed();
                        last;
                }
                Parse::RecDescent::_Runtime::_trace(q{>>'.Parse::RecDescent::_Runtime::_matchtracemessage($self).' operator: ['
                      . $self->describe
                      . ']<< (return value: [}
                                            . qq{@{$_tok||[]}} . q{]},
                                            Parse::RecDescent::_Runtime::_tracefirst($text),
                                            q{' . $rule->{"name"} .'},
                                            $tracelevel)
                                                if defined $::RD_TRACE;

                push @item, $item{'.($self->{name}||$self->{hashname}).'}=$_tok||[];
';

    return $code;
}


package Parse::RecDescent::_Runtime::Expectation;
$Parse::RecDescent::_Runtime::Expectation::VERSION = '2.20150928';
sub new ($)
{
    bless {
        "failed"      => 0,
        "expected"    => "",
        "unexpected"      => "",
        "lastexpected"    => "",
        "lastunexpected"  => "",
        "defexpected"     => $_[1],
          };
}

sub is ($$)
{
    $_[0]->{lastexpected} = $_[1]; return $_[0];
}

sub at ($$)
{
    $_[0]->{lastunexpected} = $_[1]; return $_[0];
}

sub failed ($)
{
    return unless $_[0]->{lastexpected};
    $_[0]->{expected}   = $_[0]->{lastexpected}   unless $_[0]->{failed};
    $_[0]->{unexpected} = $_[0]->{lastunexpected} unless $_[0]->{failed};
    $_[0]->{failed} = 1;
}

sub message ($)
{
    my ($self) = @_;
    $self->{expected} = $self->{defexpected} unless $self->{expected};
    $self->{expected} =~ s/_/ /g;
    if (!$self->{unexpected} || $self->{unexpected} =~ /\A\s*\Z/s)
    {
        return "Was expecting $self->{expected}";
    }
    else
    {
        $self->{unexpected} =~ /\s*(.*)/;
        return "Was expecting $self->{expected} but found \"$1\" instead";
    }
}

1;

package Parse::RecDescent::_Runtime;

use Carp;
use vars qw ( $AUTOLOAD $VERSION $_FILENAME);

my $ERRORS = 0;

our $VERSION = '1.967009';
$VERSION = eval $VERSION;
$_FILENAME=__FILE__;

# BUILDING A PARSER

my $nextnamespace = "namespace000001";

sub _nextnamespace()
{
    return "Parse::RecDescent::_Runtime::" . $nextnamespace++;
}

# ARGS ARE: $class, $grammar, $compiling, $namespace
sub new ($$$$)
{
    my $class = ref($_[0]) || $_[0];
    local $Parse::RecDescent::_Runtime::compiling = $_[2];
    my $name_space_name = defined $_[3]
        ? "Parse::RecDescent::_Runtime::".$_[3]
        : _nextnamespace();
    my $self =
    {
        "rules"     => {},
        "namespace" => $name_space_name,
        "startcode" => '',
        "localvars" => '',
        "_AUTOACTION" => undef,
        "_AUTOTREE"   => undef,

        # Precompiled parsers used to set _precompiled, but that
        # wasn't present in some versions of Parse::RecDescent::_Runtime used to
        # build precompiled parsers.  Instead, set a new
        # _not_precompiled flag, which is remove from future
        # Precompiled parsers at build time.
        "_not_precompiled" => 1,
    };


    if ($::RD_AUTOACTION) {
        my $sourcecode = $::RD_AUTOACTION;
        $sourcecode = "{ $sourcecode }"
            unless $sourcecode =~ /\A\s*\{.*\}\s*\Z/;
        $self->{_check}{itempos} =
            $sourcecode =~ /\@itempos\b|\$itempos\s*\[/;
        $self->{_AUTOACTION}
            = new Parse::RecDescent::_Runtime::Action($sourcecode,0,-1)
    }

    bless $self, $class;
    return $self->Replace($_[1])
}

sub Compile($$$$) {
    die "Compilation of Parse::RecDescent::_Runtime grammars not yet implemented\n";
}

sub DESTROY {
    my ($self) = @_;
    my $namespace = $self->{namespace};
    $namespace =~ s/Parse::RecDescent::_Runtime:://;
    if ($self->{_not_precompiled}) {
        # BEGIN WORKAROUND
        # Perl has a bug that creates a circular reference between
        # @ISA and that variable's stash:
        #   https://rt.perl.org/rt3/Ticket/Display.html?id=92708
        # Emptying the array before deleting the stash seems to
        # prevent the leak.  Once the ticket above has been resolved,
        # these two lines can be removed.
        no strict 'refs';
        @{$self->{namespace} . '::ISA'} = ();
        # END WORKAROUND

        # Some grammars may contain circular references between rules,
        # such as:
        #   a: 'ID' | b
        #   b: '(' a ')'
        # Unless these references are broken, the subs stay around on
        # stash deletion below.  Iterate through the stash entries and
        # for each defined code reference, set it to reference sub {}
        # instead.
        {
            local $^W; # avoid 'sub redefined' warnings.
            my $blank_sub = sub {};
            while (my ($name, $glob) = each %{"Parse::RecDescent::_Runtime::$namespace\::"}) {
                *$glob = $blank_sub if defined &$glob;
            }
        }

        # Delete the namespace's stash
        delete $Parse::RecDescent::_Runtime::{$namespace.'::'};
    }
}

# BUILDING A GRAMMAR....

# ARGS ARE: $self, $grammar, $isimplicit, $isleftop
sub Replace ($$)
{
    # set $replace = 1 for _generate
    splice(@_, 2, 0, 1);

    return _generate(@_);
}

# ARGS ARE: $self, $grammar, $isimplicit, $isleftop
sub Extend ($$)
{
    # set $replace = 0 for _generate
    splice(@_, 2, 0, 0);

    return _generate(@_);
}

sub _no_rule ($$;$)
{
    _error("Ruleless $_[0] at start of grammar.",$_[1]);
    my $desc = $_[2] ? "\"$_[2]\"" : "";
    _hint("You need to define a rule for the $_[0] $desc
                      to be part of.");
}

my $NEGLOOKAHEAD    = '\G(\s*\.\.\.\!)';
my $POSLOOKAHEAD    = '\G(\s*\.\.\.)';
my $RULE        = '\G\s*(\w+)[ \t]*:';
my $PROD        = '\G\s*([|])';
my $TOKEN       = q{\G\s*/((\\\\/|\\\\\\\\|[^/])*)/([cgimsox]*)};
my $MTOKEN      = q{\G\s*(m\s*[^\w\s])};
my $LITERAL     = q{\G\s*'((\\\\['\\\\]|[^'])*)'};
my $INTERPLIT       = q{\G\s*"((\\\\["\\\\]|[^"])*)"};
my $SUBRULE     = '\G\s*(\w+)';
my $MATCHRULE       = '\G(\s*<matchrule:)';
my $SIMPLEPAT       = '((\\s+/[^/\\\\]*(?:\\\\.[^/\\\\]*)*/)?)';
my $OPTIONAL        = '\G\((\?)'.$SIMPLEPAT.'\)';
my $ANY         = '\G\((s\?)'.$SIMPLEPAT.'\)';
my $MANY        = '\G\((s|\.\.)'.$SIMPLEPAT.'\)';
my $EXACTLY     = '\G\(([1-9]\d*)'.$SIMPLEPAT.'\)';
my $BETWEEN     = '\G\((\d+)\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
my $ATLEAST     = '\G\((\d+)\.\.'.$SIMPLEPAT.'\)';
my $ATMOST      = '\G\(\.\.([1-9]\d*)'.$SIMPLEPAT.'\)';
my $BADREP      = '\G\((-?\d+)?\.\.(-?\d+)?'.$SIMPLEPAT.'\)';
my $ACTION      = '\G\s*\{';
my $IMPLICITSUBRULE = '\G\s*\(';
my $COMMENT     = '\G\s*(#.*)';
my $COMMITMK        = '\G\s*<commit>';
my $UNCOMMITMK      = '\G\s*<uncommit>';
my $QUOTELIKEMK     = '\G\s*<perl_quotelike>';
my $CODEBLOCKMK     = '\G\s*<perl_codeblock(?:\s+([][()<>{}]+))?>';
my $VARIABLEMK      = '\G\s*<perl_variable>';
my $NOCHECKMK       = '\G\s*<nocheck>';
my $AUTOACTIONPATMK = '\G\s*<autoaction:';
my $AUTOTREEMK      = '\G\s*<autotree(?::\s*([\w:]+)\s*)?>';
my $AUTOSTUBMK      = '\G\s*<autostub>';
my $AUTORULEMK      = '\G\s*<autorule:(.*?)>';
my $REJECTMK        = '\G\s*<reject>';
my $CONDREJECTMK    = '\G\s*<reject:';
my $SCOREMK     = '\G\s*<score:';
my $AUTOSCOREMK     = '\G\s*<autoscore:';
my $SKIPMK      = '\G\s*<skip:';
my $OPMK        = '\G\s*<(left|right)op(?:=(\'.*?\'))?:';
my $ENDDIRECTIVEMK  = '\G\s*>';
my $RESYNCMK        = '\G\s*<resync>';
my $RESYNCPATMK     = '\G\s*<resync:';
my $RULEVARPATMK    = '\G\s*<rulevar:';
my $DEFERPATMK      = '\G\s*<defer:';
my $TOKENPATMK      = '\G\s*<token:';
my $AUTOERRORMK     = '\G\s*<error(\??)>';
my $MSGERRORMK      = '\G\s*<error(\??):';
my $NOCHECK     = '\G\s*<nocheck>';
my $WARNMK      = '\G\s*<warn((?::\s*(\d+)\s*)?)>';
my $HINTMK      = '\G\s*<hint>';
my $TRACEBUILDMK    = '\G\s*<trace_build((?::\s*(\d+)\s*)?)>';
my $TRACEPARSEMK    = '\G\s*<trace_parse((?::\s*(\d+)\s*)?)>';
my $UNCOMMITPROD    = $PROD.'\s*<uncommit';
my $ERRORPROD       = $PROD.'\s*<error';
my $LONECOLON       = '\G\s*:';
my $OTHER       = '\G\s*([^\s]+)';

my @lines = 0;

sub _generate
{
    my ($self, $grammar, $replace, $isimplicit, $isleftop) = (@_, 0);

    my $aftererror = 0;
    my $lookahead = 0;
    my $lookaheadspec = "";
    my $must_pop_lines;
    if (! $lines[-1]) {
        push @lines, _linecount($grammar) ;
        $must_pop_lines = 1;
    }
    $self->{_check}{itempos} = ($grammar =~ /\@itempos\b|\$itempos\s*\[/)
        unless $self->{_check}{itempos};
    for (qw(thisoffset thiscolumn prevline prevoffset prevcolumn))
    {
        $self->{_check}{$_} =
            ($grammar =~ /\$$_/) || $self->{_check}{itempos}
                unless $self->{_check}{$_};
    }
    my $line;

    my $rule = undef;
    my $prod = undef;
    my $item = undef;
    my $lastgreedy = '';
    pos $grammar = 0;
    study $grammar;

    local $::RD_HINT  = $::RD_HINT;
    local $::RD_WARN  = $::RD_WARN;
    local $::RD_TRACE = $::RD_TRACE;
    local $::RD_CHECK = $::RD_CHECK;

    while (pos $grammar < length $grammar)
    {
        $line = $lines[-1] - _linecount($grammar) + 1;
        my $commitonly;
        my $code = "";
        my @components = ();
        if ($grammar =~ m/$COMMENT/gco)
        {
            _parse("a comment",0,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
            next;
        }
        elsif ($grammar =~ m/$NEGLOOKAHEAD/gco)
        {
            _parse("a negative lookahead",$aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
            $lookahead = $lookahead ? -$lookahead : -1;
            $lookaheadspec .= $1;
            next;   # SKIP LOOKAHEAD RESET AT END OF while LOOP
        }
        elsif ($grammar =~ m/$POSLOOKAHEAD/gco)
        {
            _parse("a positive lookahead",$aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
            $lookahead = $lookahead ? $lookahead : 1;
            $lookaheadspec .= $1;
            next;   # SKIP LOOKAHEAD RESET AT END OF while LOOP
        }
        elsif ($grammar =~ m/(?=$ACTION)/gco
            and do { ($code) = extract_codeblock($grammar); $code })
        {
            _parse("an action", $aftererror, $line, $code);
            $item = new Parse::RecDescent::_Runtime::Action($code,$lookahead,$line);
            $prod and $prod->additem($item)
                  or  $self->_addstartcode($code);
        }
        elsif ($grammar =~ m/(?=$IMPLICITSUBRULE)/gco
            and do { ($code) = extract_codeblock($grammar,'{([',undef,'(',1);
                $code })
        {
            $code =~ s/\A\s*\(|\)\Z//g;
            _parse("an implicit subrule", $aftererror, $line,
                "( $code )");
            my $implicit = $rule->nextimplicit;
            return undef
                if !$self->_generate("$implicit : $code",$replace,1);
            my $pos = pos $grammar;
            substr($grammar,$pos,0,$implicit);
            pos $grammar = $pos;;
        }
        elsif ($grammar =~ m/$ENDDIRECTIVEMK/gco)
        {

        # EXTRACT TRAILING REPETITION SPECIFIER (IF ANY)

            my ($minrep,$maxrep) = (1,$MAXREP);
            if ($grammar =~ m/\G[(]/gc)
            {
                pos($grammar)--;

                if ($grammar =~ m/$OPTIONAL/gco)
                    { ($minrep, $maxrep) = (0,1) }
                elsif ($grammar =~ m/$ANY/gco)
                    { $minrep = 0 }
                elsif ($grammar =~ m/$EXACTLY/gco)
                    { ($minrep, $maxrep) = ($1,$1) }
                elsif ($grammar =~ m/$BETWEEN/gco)
                    { ($minrep, $maxrep) = ($1,$2) }
                elsif ($grammar =~ m/$ATLEAST/gco)
                    { $minrep = $1 }
                elsif ($grammar =~ m/$ATMOST/gco)
                    { $maxrep = $1 }
                elsif ($grammar =~ m/$MANY/gco)
                    { }
                elsif ($grammar =~ m/$BADREP/gco)
                {
                    _parse("an invalid repetition specifier", 0,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                    _error("Incorrect specification of a repeated directive",
                           $line);
                    _hint("Repeated directives cannot have
                                                      a maximum repetition of zero, nor can they have
                                                      negative components in their ranges.");
                }
            }

            $prod && $prod->enddirective($line,$minrep,$maxrep);
        }
        elsif ($grammar =~ m/\G\s*<[^m]/gc)
        {
            pos($grammar)-=2;

            if ($grammar =~ m/$OPMK/gco)
            {
                # $DB::single=1;
                _parse("a $1-associative operator directive", $aftererror, $line, "<$1op:...>");
                $prod->adddirective($1, $line,$2||'');
            }
            elsif ($grammar =~ m/$UNCOMMITMK/gco)
            {
                _parse("an uncommit marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Directive('$commit=0;1',
                                  $lookahead,$line,"<uncommit>");
                $prod and $prod->additem($item)
                      or  _no_rule("<uncommit>",$line);
            }
            elsif ($grammar =~ m/$QUOTELIKEMK/gco)
            {
                _parse("an perl quotelike marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Directive(
                    'my ($match,@res);
                                          ($match,$text,undef,@res) =
                                                    Text::Balanced::extract_quotelike($text,$skip);
                                            $match ? \@res : undef;
                                        ', $lookahead,$line,"<perl_quotelike>");
                $prod and $prod->additem($item)
                      or  _no_rule("<perl_quotelike>",$line);
            }
            elsif ($grammar =~ m/$CODEBLOCKMK/gco)
            {
                my $outer = $1||"{}";
                _parse("an perl codeblock marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Directive(
                    'Text::Balanced::extract_codeblock($text,undef,$skip,\''.$outer.'\');
                                        ', $lookahead,$line,"<perl_codeblock>");
                $prod and $prod->additem($item)
                      or  _no_rule("<perl_codeblock>",$line);
            }
            elsif ($grammar =~ m/$VARIABLEMK/gco)
            {
                _parse("an perl variable marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Directive(
                    'Text::Balanced::extract_variable($text,$skip);
                                        ', $lookahead,$line,"<perl_variable>");
                $prod and $prod->additem($item)
                      or  _no_rule("<perl_variable>",$line);
            }
            elsif ($grammar =~ m/$NOCHECKMK/gco)
            {
                _parse("a disable checking marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                if ($rule)
                {
                    _error("<nocheck> directive not at start of grammar", $line);
                    _hint("The <nocheck> directive can only
                                                      be specified at the start of a
                                                      grammar (before the first rule
                                                      is defined.");
                }
                else
                {
                    local $::RD_CHECK = 1;
                }
            }
            elsif ($grammar =~ m/$AUTOSTUBMK/gco)
            {
                _parse("an autostub marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $::RD_AUTOSTUB = "";
            }
            elsif ($grammar =~ m/$AUTORULEMK/gco)
            {
                _parse("an autorule marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $::RD_AUTOSTUB = $1;
            }
            elsif ($grammar =~ m/$AUTOTREEMK/gco)
            {
                my $base = defined($1) ? $1 : "";
                my $current_match = substr($grammar, $-[0], $+[0] - $-[0]);
                $base .= "::" if $base && $base !~ /::$/;
                _parse("an autotree marker", $aftererror,$line, $current_match);
                if ($rule)
                {
                    _error("<autotree> directive not at start of grammar", $line);
                    _hint("The <autotree> directive can only
                                                      be specified at the start of a
                                                      grammar (before the first rule
                                                      is defined.");
                }
                else
                {
                    undef $self->{_AUTOACTION};
                    $self->{_AUTOTREE}{NODE}
                        = new Parse::RecDescent::_Runtime::Action(q({bless \%item, ').$base.q('.$item[0]}),0,-1);
                    $self->{_AUTOTREE}{TERMINAL}
                        = new Parse::RecDescent::_Runtime::Action(q({bless {__VALUE__=>$item[1]}, ').$base.q('.$item[0]}),0,-1);
                }
            }

            elsif ($grammar =~ m/$REJECTMK/gco)
            {
                _parse("an reject marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::UncondReject($lookahead,$line,"<reject>");
                $prod and $prod->additem($item)
                      or  _no_rule("<reject>",$line);
            }
            elsif ($grammar =~ m/(?=$CONDREJECTMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                      $code })
            {
                _parse("a (conditional) reject marker", $aftererror,$line, $code );
                $code =~ /\A\s*<reject:(.*)>\Z/s;
                my $cond = $1;
                $item = new Parse::RecDescent::_Runtime::Directive(
                          "($1) ? undef : 1", $lookahead,$line,"<reject:$cond>");
                $prod and $prod->additem($item)
                      or  _no_rule("<reject:$cond>",$line);
            }
            elsif ($grammar =~ m/(?=$SCOREMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                      $code })
            {
                _parse("a score marker", $aftererror,$line, $code );
                $code =~ /\A\s*<score:(.*)>\Z/s;
                $prod and $prod->addscore($1, $lookahead, $line)
                      or  _no_rule($code,$line);
            }
            elsif ($grammar =~ m/(?=$AUTOSCOREMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                     $code;
                       } )
            {
                _parse("an autoscore specifier", $aftererror,$line,$code);
                $code =~ /\A\s*<autoscore:(.*)>\Z/s;

                $rule and $rule->addautoscore($1,$self)
                      or  _no_rule($code,$line);

                $item = new Parse::RecDescent::_Runtime::UncondReject($lookahead,$line,$code);
                $prod and $prod->additem($item)
                      or  _no_rule($code,$line);
            }
            elsif ($grammar =~ m/$RESYNCMK/gco)
            {
                _parse("a resync to newline marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Directive(
                          'if ($text =~ s/(\A[^\n]*\n)//) { $return = 0; $1; } else { undef }',
                          $lookahead,$line,"<resync>");
                $prod and $prod->additem($item)
                      or  _no_rule("<resync>",$line);
            }
            elsif ($grammar =~ m/(?=$RESYNCPATMK)/gco
                and do { ($code) = extract_bracketed($grammar,'<');
                      $code })
            {
                _parse("a resync with pattern marker", $aftererror,$line, $code );
                $code =~ /\A\s*<resync:(.*)>\Z/s;
                $item = new Parse::RecDescent::_Runtime::Directive(
                          'if ($text =~ s/(\A'.$1.')//) { $return = 0; $1; } else { undef }',
                          $lookahead,$line,$code);
                $prod and $prod->additem($item)
                      or  _no_rule($code,$line);
            }
            elsif ($grammar =~ m/(?=$SKIPMK)/gco
                and do { ($code) = extract_codeblock($grammar,'<');
                      $code })
            {
                _parse("a skip marker", $aftererror,$line, $code );
                $code =~ /\A\s*<skip:(.*)>\Z/s;
                if ($rule) {
                    $item = new Parse::RecDescent::_Runtime::Directive(
                        'my $oldskip = $skip; $skip='.$1.'; $oldskip',
                        $lookahead,$line,$code);
                    $prod and $prod->additem($item)
                      or  _no_rule($code,$line);
                } else {
                    #global <skip> directive
                    $self->{skip} = $1;
                }
            }
            elsif ($grammar =~ m/(?=$RULEVARPATMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                     $code;
                       } )
            {
                _parse("a rule variable specifier", $aftererror,$line,$code);
                $code =~ /\A\s*<rulevar:(.*)>\Z/s;

                $rule and $rule->addvar($1,$self)
                      or  _no_rule($code,$line);

                $item = new Parse::RecDescent::_Runtime::UncondReject($lookahead,$line,$code);
                $prod and $prod->additem($item)
                      or  _no_rule($code,$line);
            }
            elsif ($grammar =~ m/(?=$AUTOACTIONPATMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                     $code;
                       } )
            {
                _parse("an autoaction specifier", $aftererror,$line,$code);
                $code =~ s/\A\s*<autoaction:(.*)>\Z/$1/s;
                if ($code =~ /\A\s*[^{]|[^}]\s*\Z/) {
                    $code = "{ $code }"
                }
        $self->{_check}{itempos} =
            $code =~ /\@itempos\b|\$itempos\s*\[/;
        $self->{_AUTOACTION}
            = new Parse::RecDescent::_Runtime::Action($code,0,-$line)
            }
            elsif ($grammar =~ m/(?=$DEFERPATMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                     $code;
                       } )
            {
                _parse("a deferred action specifier", $aftererror,$line,$code);
                $code =~ s/\A\s*<defer:(.*)>\Z/$1/s;
                if ($code =~ /\A\s*[^{]|[^}]\s*\Z/)
                {
                    $code = "{ $code }"
                }

                $item = new Parse::RecDescent::_Runtime::Directive(
                          "push \@{\$thisparser->{deferred}}, sub $code;",
                          $lookahead,$line,"<defer:$code>");
                $prod and $prod->additem($item)
                      or  _no_rule("<defer:$code>",$line);

                $self->{deferrable} = 1;
            }
            elsif ($grammar =~ m/(?=$TOKENPATMK)/gco
                and do { ($code) = extract_codeblock($grammar,'{',undef,'<');
                     $code;
                       } )
            {
                _parse("a token constructor", $aftererror,$line,$code);
                $code =~ s/\A\s*<token:(.*)>\Z/$1/s;

                my $types = eval 'no strict; local $SIG{__WARN__} = sub {0}; my @arr=('.$code.'); @arr' || ();
                if (!$types)
                {
                    _error("Incorrect token specification: \"$@\"", $line);
                    _hint("The <token:...> directive requires a list
                                                      of one or more strings representing possible
                                                      types of the specified token. For example:
                                                      <token:NOUN,VERB>");
                }
                else
                {
                    $item = new Parse::RecDescent::_Runtime::Directive(
                              'no strict;
                                                              $return = { text => $item[-1] };
                                                              @{$return->{type}}{'.$code.'} = (1..'.$types.');',
                              $lookahead,$line,"<token:$code>");
                    $prod and $prod->additem($item)
                          or  _no_rule("<token:$code>",$line);
                }
            }
            elsif ($grammar =~ m/$COMMITMK/gco)
            {
                _parse("an commit marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Directive('$commit = 1',
                                  $lookahead,$line,"<commit>");
                $prod and $prod->additem($item)
                      or  _no_rule("<commit>",$line);
            }
            elsif ($grammar =~ m/$NOCHECKMK/gco) {
                _parse("an hint request", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
        $::RD_CHECK = 0;
        }
            elsif ($grammar =~ m/$HINTMK/gco) {
                _parse("an hint request", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
        $::RD_HINT = $self->{__HINT__} = 1;
        }
            elsif ($grammar =~ m/$WARNMK/gco) {
                _parse("an warning request", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
        $::RD_WARN = $self->{__WARN__} = $1 ? $2+0 : 1;
        }
            elsif ($grammar =~ m/$TRACEBUILDMK/gco) {
                _parse("an grammar build trace request", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
        $::RD_TRACE = $1 ? $2+0 : 1;
        }
            elsif ($grammar =~ m/$TRACEPARSEMK/gco) {
                _parse("an parse trace request", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
        $self->{__TRACE__} = $1 ? $2+0 : 1;
        }
            elsif ($grammar =~ m/$AUTOERRORMK/gco)
            {
                $commitonly = $1;
                _parse("an error marker", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
                $item = new Parse::RecDescent::_Runtime::Error('',$lookahead,$1,$line);
                $prod and $prod->additem($item)
                      or  _no_rule("<error>",$line);
                $aftererror = !$commitonly;
            }
            elsif ($grammar =~ m/(?=$MSGERRORMK)/gco
                and do { $commitonly = $1;
                     ($code) = extract_bracketed($grammar,'<');
                    $code })
            {
                _parse("an error marker", $aftererror,$line,$code);
                $code =~ /\A\s*<error\??:(.*)>\Z/s;
                $item = new Parse::RecDescent::_Runtime::Error($1,$lookahead,$commitonly,$line);
                $prod and $prod->additem($item)
                      or  _no_rule("$code",$line);
                $aftererror = !$commitonly;
            }
            elsif (do { $commitonly = $1;
                     ($code) = extract_bracketed($grammar,'<');
                    $code })
            {
                if ($code =~ /^<[A-Z_]+>$/)
                {
                    _error("Token items are not yet
                                        supported: \"$code\"",
                           $line);
                    _hint("Items like $code that consist of angle
                                        brackets enclosing a sequence of
                                        uppercase characters will eventually
                                        be used to specify pre-lexed tokens
                                        in a grammar. That functionality is not
                                        yet implemented. Or did you misspell
                                        \"$code\"?");
                }
                else
                {
                    _error("Untranslatable item encountered: \"$code\"",
                           $line);
                    _hint("Did you misspell \"$code\"
                                                      or forget to comment it out?");
                }
            }
        }
        elsif ($grammar =~ m/$RULE/gco)
        {
            _parseunneg("a rule declaration", 0,
                    $lookahead,$line, substr($grammar, $-[0], $+[0] - $-[0]) ) or next;
            my $rulename = $1;
            if ($rulename =~ /Replace|Extend|Precompile|Save/ )
            {
                _warn(2,"Rule \"$rulename\" hidden by method
                                              Parse::RecDescent::_Runtime::$rulename",$line)
                and
                _hint("The rule named \"$rulename\" cannot be directly
                                              called through the Parse::RecDescent::_Runtime object
                                              for this grammar (although it may still
                                              be used as a subrule of other rules).
                                              It can't be directly called because
                                              Parse::RecDescent::_Runtime::$rulename is already defined (it
                                              is the standard method of all
                                              parsers).");
            }
            $rule = new Parse::RecDescent::_Runtime::Rule($rulename,$self,$line,$replace);
            $prod->check_pending($line) if $prod;
            $prod = $rule->addprod( new Parse::RecDescent::_Runtime::Production );
            $aftererror = 0;
        }
        elsif ($grammar =~ m/$UNCOMMITPROD/gco)
        {
            pos($grammar)-=9;
            _parseunneg("a new (uncommitted) production",
                    0, $lookahead, $line, substr($grammar, $-[0], $+[0] - $-[0]) ) or next;

            $prod->check_pending($line) if $prod;
            $prod = new Parse::RecDescent::_Runtime::Production($line,1);
            $rule and $rule->addprod($prod)
                  or  _no_rule("<uncommit>",$line);
            $aftererror = 0;
        }
        elsif ($grammar =~ m/$ERRORPROD/gco)
        {
            pos($grammar)-=6;
            _parseunneg("a new (error) production", $aftererror,
                    $lookahead,$line, substr($grammar, $-[0], $+[0] - $-[0]) ) or next;
            $prod->check_pending($line) if $prod;
            $prod = new Parse::RecDescent::_Runtime::Production($line,0,1);
            $rule and $rule->addprod($prod)
                  or  _no_rule("<error>",$line);
            $aftererror = 0;
        }
        elsif ($grammar =~ m/$PROD/gco)
        {
            _parseunneg("a new production", 0,
                    $lookahead,$line, substr($grammar, $-[0], $+[0] - $-[0]) ) or next;
            $rule
              and (!$prod || $prod->check_pending($line))
              and $prod = $rule->addprod(new Parse::RecDescent::_Runtime::Production($line))
            or  _no_rule("production",$line);
            $aftererror = 0;
        }
        elsif ($grammar =~ m/$LITERAL/gco)
        {
            my $literal = $1;
            ($code = $literal) =~ s/\\\\/\\/g;
            _parse("a literal terminal", $aftererror,$line,$literal);
            $item = new Parse::RecDescent::_Runtime::Literal($code,$lookahead,$line);
            $prod and $prod->additem($item)
                  or  _no_rule("literal terminal",$line,"'$literal'");
        }
        elsif ($grammar =~ m/$INTERPLIT/gco)
        {
            _parse("an interpolated literal terminal", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
            $item = new Parse::RecDescent::_Runtime::InterpLit($1,$lookahead,$line);
            $prod and $prod->additem($item)
                  or  _no_rule("interpolated literal terminal",$line,"'$1'");
        }
        elsif ($grammar =~ m/$TOKEN/gco)
        {
            _parse("a /../ pattern terminal", $aftererror,$line, substr($grammar, $-[0], $+[0] - $-[0]) );
            $item = new Parse::RecDescent::_Runtime::Token($1,'/',$3?$3:'',$lookahead,$line);
            $prod and $prod->additem($item)
                  or  _no_rule("pattern terminal",$line,"/$1/");
        }
        elsif ($grammar =~ m/(?=$MTOKEN)/gco
            and do { ($code, undef, @components)
                    = extract_quotelike($grammar);
                 $code }
              )

        {
            _parse("an m/../ pattern terminal", $aftererror,$line,$code);
            $item = new Parse::RecDescent::_Runtime::Token(@components[3,2,8],
                                 $lookahead,$line);
            $prod and $prod->additem($item)
                  or  _no_rule("pattern terminal",$line,$code);
        }
        elsif ($grammar =~ m/(?=$MATCHRULE)/gco
                and do { ($code) = extract_bracketed($grammar,'<');
                     $code
                       }
               or $grammar =~ m/$SUBRULE/gco
                and $code = $1)
        {
            my $name = $code;
            my $matchrule = 0;
            if (substr($name,0,1) eq '<')
            {
                $name =~ s/$MATCHRULE\s*//;
                $name =~ s/\s*>\Z//;
                $matchrule = 1;
            }

        # EXTRACT TRAILING ARG LIST (IF ANY)

            my ($argcode) = extract_codeblock($grammar, "[]",'') || '';

        # EXTRACT TRAILING REPETITION SPECIFIER (IF ANY)

            if ($grammar =~ m/\G[(]/gc)
            {
                pos($grammar)--;

                if ($grammar =~ m/$OPTIONAL/gco)
                {
                    _parse("an zero-or-one subrule match", $aftererror,$line,"$code$argcode($1)");
                    $item = new Parse::RecDescent::_Runtime::Repetition($name,$1,0,1,
                                       $lookahead,$line,
                                       $self,
                                       $matchrule,
                                       $argcode);
                    $prod and $prod->additem($item)
                          or  _no_rule("repetition",$line,"$code$argcode($1)");

                    !$matchrule and $rule and $rule->addcall($name);
                }
                elsif ($grammar =~ m/$ANY/gco)
                {
                    _parse("a zero-or-more subrule match", $aftererror,$line,"$code$argcode($1)");
                    if ($2)
                    {
                        my $pos = pos $grammar;
                        substr($grammar,$pos,0,
                               "<leftop='$name(s?)': $name $2 $name>(s?) ");

                        pos $grammar = $pos;
                    }
                    else
                    {
                        $item = new Parse::RecDescent::_Runtime::Repetition($name,$1,0,$MAXREP,
                                           $lookahead,$line,
                                           $self,
                                           $matchrule,
                                           $argcode);
                        $prod and $prod->additem($item)
                              or  _no_rule("repetition",$line,"$code$argcode($1)");

                        !$matchrule and $rule and $rule->addcall($name);

                        _check_insatiable($name,$1,$grammar,$line) if $::RD_CHECK;
                    }
                }
                elsif ($grammar =~ m/$MANY/gco)
                {
                    _parse("a one-or-more subrule match", $aftererror,$line,"$code$argcode($1)");
                    if ($2)
                    {
                        # $DB::single=1;
                        my $pos = pos $grammar;
                        substr($grammar,$pos,0,
                               "<leftop='$name(s)': $name $2 $name> ");

                        pos $grammar = $pos;
                    }
                    else
                    {
                        $item = new Parse::RecDescent::_Runtime::Repetition($name,$1,1,$MAXREP,
                                           $lookahead,$line,
                                           $self,
                                           $matchrule,
                                           $argcode);

                        $prod and $prod->additem($item)
                              or  _no_rule("repetition",$line,"$code$argcode($1)");

                        !$matchrule and $rule and $rule->addcall($name);

                        _check_insatiable($name,$1,$grammar,$line) if $::RD_CHECK;
                    }
                }
                elsif ($grammar =~ m/$EXACTLY/gco)
                {
                    _parse("an exactly-$1-times subrule match", $aftererror,$line,"$code$argcode($1)");
                    if ($2)
                    {
                        my $pos = pos $grammar;
                        substr($grammar,$pos,0,
                               "<leftop='$name($1)': $name $2 $name>($1) ");

                        pos $grammar = $pos;
                    }
                    else
                    {
                        $item = new Parse::RecDescent::_Runtime::Repetition($name,$1,$1,$1,
                                           $lookahead,$line,
                                           $self,
                                           $matchrule,
                                           $argcode);
                        $prod and $prod->additem($item)
                              or  _no_rule("repetition",$line,"$code$argcode($1)");

                        !$matchrule and $rule and $rule->addcall($name);
                    }
                }
                elsif ($grammar =~ m/$BETWEEN/gco)
                {
                    _parse("a $1-to-$2 subrule match", $aftererror,$line,"$code$argcode($1..$2)");
                    if ($3)
                    {
                        my $pos = pos $grammar;
                        substr($grammar,$pos,0,
                               "<leftop='$name($1..$2)': $name $3 $name>($1..$2) ");

                        pos $grammar = $pos;
                    }
                    else
                    {
                        $item = new Parse::RecDescent::_Runtime::Repetition($name,"$1..$2",$1,$2,
                                           $lookahead,$line,
                                           $self,
                                           $matchrule,
                                           $argcode);
                        $prod and $prod->additem($item)
                              or  _no_rule("repetition",$line,"$code$argcode($1..$2)");

                        !$matchrule and $rule and $rule->addcall($name);
                    }
                }
                elsif ($grammar =~ m/$ATLEAST/gco)
                {
                    _parse("a $1-or-more subrule match", $aftererror,$line,"$code$argcode($1..)");
                    if ($2)
                    {
                        my $pos = pos $grammar;
                        substr($grammar,$pos,0,
                               "<leftop='$name($1..)': $name $2 $name>($1..) ");

                        pos $grammar = $pos;
                    }
                    else
                    {
                        $item = new Parse::RecDescent::_Runtime::Repetition($name,"$1..",$1,$MAXREP,
                                           $lookahead,$line,
                                           $self,
                                           $matchrule,
                                           $argcode);
                        $prod and $prod->additem($item)
                              or  _no_rule("repetition",$line,"$code$argcode($1..)");

                        !$matchrule and $rule and $rule->addcall($name);
                        _check_insatiable($name,"$1..",$grammar,$line) if $::RD_CHECK;
                    }
                }
                elsif ($grammar =~ m/$ATMOST/gco)
                {
                    _parse("a one-to-$1 subrule match", $aftererror,$line,"$code$argcode(..$1)");
                    if ($2)
                    {
                        my $pos = pos $grammar;
                        substr($grammar,$pos,0,
                               "<leftop='$name(..$1)': $name $2 $name>(..$1) ");

                        pos $grammar = $pos;
                    }
                    else
                    {
                        $item = new Parse::RecDescent::_Runtime::Repetition($name,"..$1",1,$1,
                                           $lookahead,$line,
                                           $self,
                                           $matchrule,
                                           $argcode);
                        $prod and $prod->additem($item)
                              or  _no_rule("repetition",$line,"$code$argcode(..$1)");

                        !$matchrule and $rule and $rule->addcall($name);
                    }
                }
                elsif ($grammar =~ m/$BADREP/gco)
                {
                    my $current_match = substr($grammar, $-[0], $+[0] - $-[0]);
                    _parse("an subrule match with invalid repetition specifier", 0,$line, $current_match);
                    _error("Incorrect specification of a repeated subrule",
                           $line);
                    _hint("Repeated subrules like \"$code$argcode$current_match\" cannot have
                                                      a maximum repetition of zero, nor can they have
                                                      negative components in their ranges.");
                }
            }
            else
            {
                _parse("a subrule match", $aftererror,$line,$code);
                my $desc;
                if ($name=~/\A_alternation_\d+_of_production_\d+_of_rule/)
                    { $desc = $self->{"rules"}{$name}->expected }
                $item = new Parse::RecDescent::_Runtime::Subrule($name,
                                       $lookahead,
                                       $line,
                                       $desc,
                                       $matchrule,
                                       $argcode);

                $prod and $prod->additem($item)
                      or  _no_rule("(sub)rule",$line,$name);

                !$matchrule and $rule and $rule->addcall($name);
            }
        }
        elsif ($grammar =~ m/$LONECOLON/gco   )
        {
            _error("Unexpected colon encountered", $line);
            _hint("Did you mean \"|\" (to start a new production)?
                                      Or perhaps you forgot that the colon
                                      in a rule definition must be
                                      on the same line as the rule name?");
        }
        elsif ($grammar =~ m/$ACTION/gco   ) # BAD ACTION, ALREADY FAILED
        {
            _error("Malformed action encountered",
                   $line);
            _hint("Did you forget the closing curly bracket
                                      or is there a syntax error in the action?");
        }
        elsif ($grammar =~ m/$OTHER/gco   )
        {
            _error("Untranslatable item encountered: \"$1\"",
                   $line);
            _hint("Did you misspell \"$1\"
                                      or forget to comment it out?");
        }

        if ($lookaheadspec =~ tr /././ > 3)
        {
            $lookaheadspec =~ s/\A\s+//;
            $lookahead = $lookahead<0
                    ? 'a negative lookahead ("...!")'
                    : 'a positive lookahead ("...")' ;
            _warn(1,"Found two or more lookahead specifiers in a
                                      row.",$line)
            and
            _hint("Multiple positive and/or negative lookaheads
                                      are simply multiplied together to produce a
                                      single positive or negative lookahead
                                      specification. In this case the sequence
                                      \"$lookaheadspec\" was reduced to $lookahead.
                                      Was this your intention?");
        }
        $lookahead = 0;
        $lookaheadspec = "";

        $grammar =~ m/\G\s+/gc;
    }

    if ($must_pop_lines) {
        pop @lines;
    }

    unless ($ERRORS or $isimplicit or !$::RD_CHECK)
    {
        $self->_check_grammar();
    }

    unless ($ERRORS or $isimplicit or $Parse::RecDescent::_Runtime::compiling)
    {
        my $code = $self->_code();
        if (defined $::RD_TRACE)
        {
            my $mode = ($nextnamespace eq "namespace000002") ? '>' : '>>';
            print STDERR "printing code (", length($code),") to RD_TRACE\n";
            local *TRACE_FILE;
            open TRACE_FILE, $mode, "RD_TRACE"
            and print TRACE_FILE "my \$ERRORS;\n$code"
            and close TRACE_FILE;
        }

        unless ( eval "$code 1" )
        {
            _error("Internal error in generated parser code!");
            $@ =~ s/at grammar/in grammar at/;
            _hint($@);
        }
    }

    if ($ERRORS and !_verbosity("HINT"))
    {
        local $::RD_HINT = defined $::RD_HINT ? $::RD_HINT : 1;
        _hint('Set $::RD_HINT (or -RD_HINT if you\'re using "perl -s")
                              for hints on fixing these problems.  Use $::RD_HINT = 0
                              to disable this message.');
    }
    if ($ERRORS) { $ERRORS=0; return }
    return $self;
}


sub _addstartcode($$)
{
    my ($self, $code) = @_;
    $code =~ s/\A\s*\{(.*)\}\Z/$1/s;

    $self->{"startcode"} .= "$code;\n";
}

# CHECK FOR GRAMMAR PROBLEMS....

sub _check_insatiable($$$$)
{
    my ($subrule,$repspec,$grammar,$line) = @_;
    pos($grammar)=pos($_[2]);
    return if $grammar =~ m/$OPTIONAL/gco || $grammar =~ m/$ANY/gco;
    my $min = 1;
    if ( $grammar =~ m/$MANY/gco
      || $grammar =~ m/$EXACTLY/gco
      || $grammar =~ m/$ATMOST/gco
      || $grammar =~ m/$BETWEEN/gco && do { $min=$2; 1 }
      || $grammar =~ m/$ATLEAST/gco && do { $min=$2; 1 }
      || $grammar =~ m/$SUBRULE(?!\s*:)/gco
       )
    {
        return unless $1 eq $subrule && $min > 0;
        my $current_match = substr($grammar, $-[0], $+[0] - $-[0]);
        _warn(3,"Subrule sequence \"$subrule($repspec) $current_match\" will
                              (almost certainly) fail.",$line)
        and
        _hint("Unless subrule \"$subrule\" performs some cunning
                              lookahead, the repetition \"$subrule($repspec)\" will
                              insatiably consume as many matches of \"$subrule\" as it
                              can, leaving none to match the \"$current_match\" that follows.");
    }
}

sub _check_grammar ($)
{
    my $self = shift;
    my $rules = $self->{"rules"};
    my $rule;
    foreach $rule ( values %$rules )
    {
        next if ! $rule->{"changed"};

    # CHECK FOR UNDEFINED RULES

        my $call;
        foreach $call ( @{$rule->{"calls"}} )
        {
            if (!defined ${$rules}{$call}
              &&!defined &{"Parse::RecDescent::_Runtime::$call"})
            {
                if (!defined $::RD_AUTOSTUB)
                {
                    _warn(3,"Undefined (sub)rule \"$call\"
                                                    used in a production.")
                    and
                    _hint("Will you be providing this rule
                                                      later, or did you perhaps
                                                      misspell \"$call\"? Otherwise
                                                      it will be treated as an
                                                      immediate <reject>.");
                    eval "sub $self->{namespace}::$call {undef}";
                }
                else    # EXPERIMENTAL
                {
                    my $rule = qq{'$call'};
                    if ($::RD_AUTOSTUB and $::RD_AUTOSTUB ne "1") {
                        $rule = $::RD_AUTOSTUB;
                    }
                    _warn(1,"Autogenerating rule: $call")
                    and
                    _hint("A call was made to a subrule
                                                      named \"$call\", but no such
                                                      rule was specified. However,
                                                      since \$::RD_AUTOSTUB
                                                      was defined, a rule stub
                                                      ($call : $rule) was
                                                      automatically created.");

                    $self->_generate("$call: $rule",0,1);
                }
            }
        }

    # CHECK FOR LEFT RECURSION

        if ($rule->isleftrec($rules))
        {
            _error("Rule \"$rule->{name}\" is left-recursive.");
            _hint("Redesign the grammar so it's not left-recursive.
                                      That will probably mean you need to re-implement
                                      repetitions using the '(s)' notation.
                                      For example: \"$rule->{name}(s)\".");
            next;
        }

    # CHECK FOR PRODUCTIONS FOLLOWING EMPTY PRODUCTIONS
      {
          my $hasempty;
          my $prod;
          foreach $prod ( @{$rule->{"prods"}} ) {
              if ($hasempty) {
                  _error("Production " . $prod->describe . " for \"$rule->{name}\"
                                                  will never be reached (preceding empty production will
                                                  always match first).");
                  _hint("Reorder the grammar so that the empty production
                                                  is last in the list or productions.");
                  last;
              }
              $hasempty ||= $prod->isempty();
          }
      }
    }
}

# GENERATE ACTUAL PARSER CODE

sub _code($)
{
    my $self = shift;
    my $initial_skip = defined($self->{skip}) ? $self->{skip} : $skip;

    my $code = qq!
package $self->{namespace};
use strict;
use vars qw(\$skip \$AUTOLOAD $self->{localvars} );
\@$self->{namespace}\::ISA = ();
\$skip = '$initial_skip';
$self->{startcode}

{
local \$SIG{__WARN__} = sub {0};
# PRETEND TO BE IN Parse::RecDescent::_Runtime NAMESPACE
*$self->{namespace}::AUTOLOAD   = sub
{
        no strict 'refs';
!
# This generated code uses ${"AUTOLOAD"} rather than $AUTOLOAD in
# order to avoid the circular reference documented here:
#    https://rt.perl.org/rt3/Public/Bug/Display.html?id=110248
# As a result of the investigation of
#    https://rt.cpan.org/Ticket/Display.html?id=53710
. qq!
        \${"AUTOLOAD"} =~ s/^$self->{namespace}/Parse::RecDescent::_Runtime/;
        goto &{\${"AUTOLOAD"}};
}
}

!;
    $code .= "push \@$self->{namespace}\::ISA, 'Parse::RecDescent::_Runtime';";
    $self->{"startcode"} = '';

    my $rule;
    foreach $rule ( values %{$self->{"rules"}} )
    {
        if ($rule->{"changed"})
        {
            $code .= $rule->code($self->{"namespace"},$self);
            $rule->{"changed"} = 0;
        }
    }

    return $code;
}


# EXECUTING A PARSE....

sub AUTOLOAD    # ($parser, $text; $linenum, @args)
{
    croak "Could not find method: $AUTOLOAD\n" unless ref $_[0];
    my $class = ref($_[0]) || $_[0];
    my $text = ref($_[1]) eq 'SCALAR' ? ${$_[1]} : "$_[1]";
    $_[0]->{lastlinenum} = _linecount($text);
    $_[0]->{lastlinenum} += ($_[2]||0) if @_ > 2;
    $_[0]->{offsetlinenum} = $_[0]->{lastlinenum};
    $_[0]->{fulltext} = $text;
    $_[0]->{fulltextlen} = length $text;
    $_[0]->{linecounter_cache} = {};
    $_[0]->{deferred} = [];
    $_[0]->{errors} = [];
    my @args = @_[3..$#_];
    my $args = sub { [ @args ] };

    $AUTOLOAD =~ s/$class/$_[0]->{namespace}/;
    no strict "refs";

    local $::RD_WARN  = $::RD_WARN  || $_[0]->{__WARN__};
    local $::RD_HINT  = $::RD_HINT  || $_[0]->{__HINT__};
    local $::RD_TRACE = $::RD_TRACE || $_[0]->{__TRACE__};

    croak "Unknown starting rule ($AUTOLOAD) called\n"
        unless defined &$AUTOLOAD;
    my $retval = &{$AUTOLOAD}(
        $_[0], # $parser
        $text, # $text
        undef, # $repeating
        undef, # $_noactions
        $args, # \@args
        undef, # $_itempos
    );


    if (defined $retval)
    {
        foreach ( @{$_[0]->{deferred}} ) { &$_; }
    }
    else
    {
        foreach ( @{$_[0]->{errors}} ) { _error(@$_); }
    }

    if (ref $_[1] eq 'SCALAR') { ${$_[1]} = $text }

    $ERRORS = 0;
    return $retval;
}

sub _parserepeat($$$$$$$$$)    # RETURNS A REF TO AN ARRAY OF MATCHES
{
    my ($parser, $text, $prod, $min, $max, $_noactions, $expectation, $argcode, $_itempos) = @_;
    my @tokens = ();

    my $itemposfirst;
    my $reps;
    for ($reps=0; $reps<$max;)
    {
        $expectation->at($text);
        my $_savetext = $text;
        my $prevtextlen = length $text;
        my $_tok;
        if (! defined ($_tok = &$prod($parser,$text,1,$_noactions,$argcode,$_itempos)))
        {
            $text = $_savetext;
            last;
        }

        if (defined($_itempos) and !defined($itemposfirst))
        {
            $itemposfirst = Parse::RecDescent::_Runtime::Production::_duplicate_itempos($_itempos);
        }

        push @tokens, $_tok if defined $_tok;
        last if ++$reps >= $min and $prevtextlen == length $text;
    }

    do { $expectation->failed(); return undef} if $reps<$min;

    if (defined $itemposfirst)
    {
        Parse::RecDescent::_Runtime::Production::_update_itempos($_itempos, $itemposfirst, undef, [qw(from)]);
    }

    $_[1] = $text;
    return [@tokens];
}

sub set_autoflush {
    my $orig_selected = select $_[0];
    $| = 1;
    select $orig_selected;
    return;
}

# ERROR REPORTING....

sub _write_ERROR {
    my ($errorprefix, $errortext) = @_;
    return if $errortext !~ /\S/;
    $errorprefix =~ s/\s+\Z//;
    local $^A = q{};

    formline(<<'END_FORMAT', $errorprefix, $errortext);
@>>>>>>>>>>>>>>>>>>>>: ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
END_FORMAT
    formline(<<'END_FORMAT', $errortext);
~~                     ^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
END_FORMAT
    print {*STDERR} $^A;
}

# TRACING

my $TRACE_FORMAT = <<'END_FORMAT';
@>|@|||||||||@^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<|
  | ~~       |^<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<|
END_FORMAT

my $TRACECONTEXT_FORMAT = <<'END_FORMAT';
@>|@|||||||||@                                      |^<<<<<<<<<<<<<<<<<<<<<<<<<<<
  | ~~       |                                      |^<<<<<<<<<<<<<<<<<<<<<<<<<<<
END_FORMAT

sub _write_TRACE {
    my ($tracelevel, $tracerulename, $tracemsg) = @_;
    return if $tracemsg !~ /\S/;
    $tracemsg =~ s/\s*\Z//;
    local $^A = q{};
    my $bar = '|';
    formline($TRACE_FORMAT, $tracelevel, $tracerulename, $bar, $tracemsg, $tracemsg);
    print {*STDERR} $^A;
}

sub _write_TRACECONTEXT {
    my ($tracelevel, $tracerulename, $tracecontext) = @_;
    return if $tracecontext !~ /\S/;
    $tracecontext =~ s/\s*\Z//;
    local $^A = q{};
    my $bar = '|';
    formline($TRACECONTEXT_FORMAT, $tracelevel, $tracerulename, $bar, $tracecontext, $tracecontext);
    print {*STDERR} $^A;
}

sub _verbosity($)
{
       defined $::RD_TRACE
    or defined $::RD_HINT    and  $::RD_HINT   and $_[0] =~ /ERRORS|WARN|HINT/
    or defined $::RD_WARN    and  $::RD_WARN   and $_[0] =~ /ERRORS|WARN/
    or defined $::RD_ERRORS  and  $::RD_ERRORS and $_[0] =~ /ERRORS/
}

sub _error($;$)
{
    $ERRORS++;
    return 0 if ! _verbosity("ERRORS");
    my $errortext   = $_[0];
    my $errorprefix = "ERROR" .  ($_[1] ? " (line $_[1])" : "");
    $errortext =~ s/\s+/ /g;
    print {*STDERR} "\n" if _verbosity("WARN");
    _write_ERROR($errorprefix, $errortext);
    return 1;
}

sub _warn($$;$)
{
    return 0 unless _verbosity("WARN") && ($::RD_HINT || $_[0] >= ($::RD_WARN||1));
    my $errortext   = $_[1];
    my $errorprefix = "Warning" .  ($_[2] ? " (line $_[2])" : "");
    print {*STDERR} "\n" if _verbosity("HINT");
    $errortext =~ s/\s+/ /g;
    _write_ERROR($errorprefix, $errortext);
    return 1;
}

sub _hint($)
{
    return 0 unless $::RD_HINT;
    my $errortext = $_[0];
    my $errorprefix = "Hint" .  ($_[1] ? " (line $_[1])" : "");
    $errortext =~ s/\s+/ /g;
    _write_ERROR($errorprefix, $errortext);
    return 1;
}

sub _tracemax($)
{
    if (defined $::RD_TRACE
        && $::RD_TRACE =~ /\d+/
        && $::RD_TRACE>1
        && $::RD_TRACE+10<length($_[0]))
    {
        my $count = length($_[0]) - $::RD_TRACE;
        return substr($_[0],0,$::RD_TRACE/2)
            . "...<$count>..."
            . substr($_[0],-$::RD_TRACE/2);
    }
    else
    {
        return substr($_[0],0,500);
    }
}

sub _tracefirst($)
{
    if (defined $::RD_TRACE
        && $::RD_TRACE =~ /\d+/
        && $::RD_TRACE>1
        && $::RD_TRACE+10<length($_[0]))
    {
        my $count = length($_[0]) - $::RD_TRACE;
        return substr($_[0],0,$::RD_TRACE) . "...<+$count>";
    }
    else
    {
        return substr($_[0],0,500);
    }
}

my $lastcontext = '';
my $lastrulename = '';
my $lastlevel = '';

sub _trace($;$$$)
{
    my $tracemsg      = $_[0];
    my $tracecontext  = $_[1]||$lastcontext;
    my $tracerulename = $_[2]||$lastrulename;
    my $tracelevel    = $_[3]||$lastlevel;
    if ($tracerulename) { $lastrulename = $tracerulename }
    if ($tracelevel)    { $lastlevel = $tracelevel }

    $tracecontext =~ s/\n/\\n/g;
    $tracecontext =~ s/\s+/ /g;
    $tracerulename = qq{$tracerulename};
    _write_TRACE($tracelevel, $tracerulename, $tracemsg);
    if ($tracecontext ne $lastcontext)
    {
        if ($tracecontext)
        {
            $lastcontext = _tracefirst($tracecontext);
            $tracecontext = qq{"$tracecontext"};
        }
        else
        {
            $tracecontext = qq{<NO TEXT LEFT>};
        }
        _write_TRACECONTEXT($tracelevel, $tracerulename, $tracecontext);
    }
}

sub _matchtracemessage
{
    my ($self, $reject) = @_;

    my $prefix = '';
    my $postfix = '';
    my $matched = not $reject;
    my @t = ("Matched", "Didn't match");
    if (exists $self->{lookahead} and $self->{lookahead})
    {
        $postfix = $reject ? "(reject)" : "(keep)";
        $prefix = "...";
        if ($self->{lookahead} < 0)
        {
            $prefix .= '!';
            $matched = not $matched;
        }
    }
    $prefix . ($matched ? $t[0] : $t[1]) . $postfix;
}

sub _parseunneg($$$$$)
{
    _parse($_[0],$_[1],$_[3],$_[4]);
    if ($_[2]<0)
    {
        _error("Can't negate \"$_[4]\".",$_[3]);
        _hint("You can't negate $_[0]. Remove the \"...!\" before
                              \"$_[4]\".");
        return 0;
    }
    return 1;
}

sub _parse($$$$)
{
    my $what = $_[3];
       $what =~ s/^\s+//;
    if ($_[1])
    {
        _warn(3,"Found $_[0] ($what) after an unconditional <error>",$_[2])
        and
        _hint("An unconditional <error> always causes the
                              production containing it to immediately fail.
                              \u$_[0] that follows an <error>
                              will never be reached.  Did you mean to use
                              <error?> instead?");
    }

    return if ! _verbosity("TRACE");
    my $errortext = "Treating \"$what\" as $_[0]";
    my $errorprefix = "Parse::RecDescent::_Runtime";
    $errortext =~ s/\s+/ /g;
    _write_ERROR($errorprefix, $errortext);
}

sub _linecount($) {
    scalar substr($_[0], pos $_[0]||0) =~ tr/\n//
}


package main;
$main::VERSION = '2.20150928';
use vars qw ( $RD_ERRORS $RD_WARN $RD_HINT $RD_TRACE $RD_CHECK );
$::RD_CHECK = 1;
$::RD_ERRORS = 1;
$::RD_WARN = 3;

1;

}
package Treex::Core::ScenarioParser;
$Treex::Core::ScenarioParser::VERSION = '2.20150928';
{ my $ERRORS;


package Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser;
$Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::VERSION = '2.20150928';
use strict;
use vars qw($skip $AUTOLOAD  );
@Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::ISA = ();
$skip = '\s*';

use File::Slurp;
use File::Basename;
use Treex::Core::Log;
## no critic (Miscellanea::ProhibitUnrestrictedNoCritic)
## no critic Generated code follows
no warnings;
;


{
local $SIG{__WARN__} = sub {0};
# PRETEND TO BE IN Parse::RecDescent::_Runtime NAMESPACE
*Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::AUTOLOAD   = sub
{
    no strict 'refs';

    ${"AUTOLOAD"} =~ s/^Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser/Parse::RecDescent::_Runtime/;
    goto &{${"AUTOLOAD"}};
}
}

push @Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::ISA, 'Parse::RecDescent::_Runtime';
# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PNOTQUOTED
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PNOTQUOTED"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PNOTQUOTED]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PNOTQUOTED},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/\\S+/, or EMPTY});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/\\S+/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PNOTQUOTED});
        %item = (__RULE__ => q{PNOTQUOTED});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/\\S+/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:\S+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/\\S+/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [EMPTY]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{PNOTQUOTED});
        %item = (__RULE__ => q{PNOTQUOTED});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [EMPTY]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PNOTQUOTED},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::EMPTY($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [EMPTY]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PNOTQUOTED},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [EMPTY]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{EMPTY}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = ''};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [EMPTY]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PNOTQUOTED},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PNOTQUOTED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PNOTQUOTED},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PNOTQUOTED},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SPACE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SPACE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [SPACE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{SPACE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/\\s+/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/\\s+/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{SPACE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SPACE});
        %item = (__RULE__ => q{SPACE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/\\s+/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SPACE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:\s+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SPACE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/\\s+/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SPACE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{SPACE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{SPACE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SPACE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{SPACE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PDQUOTE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PDQUOTE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{NOTDQUOTE});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [NOTDQUOTE SLASHEDDQUOTE PDQUOTE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PDQUOTE});
        %item = (__RULE__ => q{PDQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [NOTDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::NOTDQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [NOTDQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PDQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [NOTDQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{NOTDQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [SLASHEDDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SLASHEDDQUOTE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SLASHEDDQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [SLASHEDDQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PDQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [SLASHEDDQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SLASHEDDQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PDQUOTE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PDQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PDQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PDQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PDQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PDQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{NOTDQUOTE}.$item{SLASHEDDQUOTE}.$item{PDQUOTE}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [NOTDQUOTE SLASHEDDQUOTE PDQUOTE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [NOTDQUOTE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{PDQUOTE});
        %item = (__RULE__ => q{PDQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [NOTDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::NOTDQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [NOTDQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PDQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [NOTDQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{NOTDQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [NOTDQUOTE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PDQUOTE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PDQUOTE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PDQUOTE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BNAME
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"BNAME"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [BNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{BNAME},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/[A-Z]\\w*::/, or /[A-Z]\\w*/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/[A-Z]\\w*::/ BNAME]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{BNAME});
        %item = (__RULE__ => q{BNAME});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/[A-Z]\\w*::/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:[A-Z]\w*::)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [BNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BNAME},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{BNAME})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [BNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BNAME},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [BNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1].$item[2]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/[A-Z]\\w*::/ BNAME]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/[A-Z]\\w*/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{BNAME});
        %item = (__RULE__ => q{BNAME});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/[A-Z]\\w*/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:[A-Z]\w*)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/[A-Z]\\w*/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{BNAME},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{BNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{BNAME},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{BNAME},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PNAME
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PNAME"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PNAME},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/\\w+/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/\\w+/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PNAME});
        %item = (__RULE__ => q{PNAME});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/\\w+/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:\w+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/\\w+/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PNAME},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PNAME},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PNAME},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::NOTSQUOTE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"NOTSQUOTE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [NOTSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{NOTSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/[^']*[^'\\\\]/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/[^']*[^'\\\\]/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{NOTSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{NOTSQUOTE});
        %item = (__RULE__ => q{NOTSQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/[^']*[^'\\\\]/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{NOTSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:[^']*[^'\\])/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/[^']*[^'\\\\]/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{NOTSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{NOTSQUOTE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{NOTSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{NOTSQUOTE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{NOTSQUOTE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::INCLUDE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"INCLUDE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [INCLUDE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{INCLUDE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/\\/\\S+\\.scen/, or /[^\\/#]\\S+\\.scen/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/\\/\\S+\\.scen/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{INCLUDE});
        %item = (__RULE__ => q{INCLUDE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/\\/\\S+\\.scen/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:\/\S+\.scen)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/\\/\\S+\\.scen/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/[^\\/#]\\S+\\.scen/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{INCLUDE});
        %item = (__RULE__ => q{INCLUDE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/[^\\/#]\\S+\\.scen/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:[^\/#]\S+\.scen)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {   my $from_file = $arg[0];
                                                    if (length $from_file) {
                                                        $return = dirname($from_file) . "/$item[1]";
                                                    } else {
                                                        $return = "./$item[1]";
                                                    }
                                                };
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/[^\\/#]\\S+\\.scen/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{INCLUDE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{INCLUDE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{INCLUDE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{INCLUDE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BLOCK
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"BLOCK"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [BLOCK]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{INCLUDE, or SCENMODULE, or TBNAME});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [INCLUDE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{BLOCK});
        %item = (__RULE__ => q{BLOCK});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [INCLUDE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::INCLUDE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [INCLUDE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [INCLUDE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{INCLUDE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {
                                                    my $included = read_file( $item{INCLUDE}, binmode => ':utf8' );
                                                    my $result = $thisparser->startrule( $included, 1, $item{INCLUDE} );
                                                    if (defined $result and ref $result eq 'ARRAY') {
                                                        $return = [@$result];
                                                    } else {
                                                        $return = undef;
                                                    }
                                                };
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [INCLUDE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [SCENMODULE PARAMS]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{BLOCK});
        %item = (__RULE__ => q{BLOCK});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [SCENMODULE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SCENMODULE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [SCENMODULE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [SCENMODULE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SCENMODULE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PARAMS]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PARAMS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAMS($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PARAMS]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PARAMS]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PARAMS}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {
                                                    my $modulename = $item{SCENMODULE};
                                                    eval "use $modulename; 1;" or die "Can't use $modulename !\n$@\n";
                                                    my %params = map {my ($name,$value) = split /=/, $_, 2; ($name, $value)} @{$item{PARAMS}};
                                                    my $scenmod = $modulename->new(\%params);
                                                    my $string = $scenmod->get_scenario_string();
                                                    my $result = $thisparser->startrule( $string, 0, '' );
                                                    if (defined $result and ref $result eq 'ARRAY') {
                                                        $return = [@$result];
                                                    } else {
                                                        log_fatal "Syntax error in '$modulename' scenario:\n<BEGIN SCENARIO>\n$string\n<END SCENARIO>";
                                                    }
                                                };
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [SCENMODULE PARAMS]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [SCENMODULE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{BLOCK});
        %item = (__RULE__ => q{BLOCK});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [SCENMODULE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SCENMODULE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [SCENMODULE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [SCENMODULE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SCENMODULE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {
                                                    my $modulename = $item{SCENMODULE};
                                                    eval "use $modulename; 1;" or die "Can't use $modulename !\n$@\n";
                                                    my $scenmod = $modulename->new();
                                                    my $string = $scenmod->get_scenario_string();
                                                    my $result = $thisparser->startrule( $string, 0, '' );
                                                    if (defined $result and ref $result eq 'ARRAY') {
                                                        $return = [@$result];
                                                    } else {
                                                        log_fatal "Syntax error in '$modulename' scenario:\n<BEGIN SCENARIO>\n$string\n<END SCENARIO>";
                                                    }
                                                };
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [SCENMODULE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [TBNAME PARAMS]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{BLOCK});
        %item = (__RULE__ => q{BLOCK});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [TBNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::TBNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [TBNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [TBNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{TBNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PARAMS]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PARAMS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAMS($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PARAMS]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PARAMS]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PARAMS}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [{
                                                        block_name=>$item{TBNAME},
                                                        block_parameters=>$item{PARAMS},
                                                    }]
                                                };
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [TBNAME PARAMS]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [TBNAME]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{BLOCK});
        %item = (__RULE__ => q{BLOCK});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [TBNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{BLOCK},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::TBNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [TBNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{BLOCK},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [TBNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{TBNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [{
                                                        block_name=>$item{TBNAME},
                                                        block_parameters=>[],
                                                    }]
                                                };
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [TBNAME]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{BLOCK},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{BLOCK},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{BLOCK},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{BLOCK},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SLASHEDDQUOTE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SLASHEDDQUOTE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [SLASHEDDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{SLASHEDDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/\\\\"/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/\\\\"/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{SLASHEDDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SLASHEDDQUOTE});
        %item = (__RULE__ => q{SLASHEDDQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/\\\\"/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SLASHEDDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:\\")/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SLASHEDDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = '"'};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/\\\\"/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SLASHEDDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{SLASHEDDQUOTE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{SLASHEDDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SLASHEDDQUOTE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{SLASHEDDQUOTE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::NOTDQUOTE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"NOTDQUOTE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [NOTDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{NOTDQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/[^"]*[^"\\\\]/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/[^"]*[^"\\\\]/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{NOTDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{NOTDQUOTE});
        %item = (__RULE__ => q{NOTDQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/[^"]*[^"\\\\]/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{NOTDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:[^"]*[^"\\])/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/[^"]*[^"\\\\]/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{NOTDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{NOTDQUOTE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{NOTDQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{NOTDQUOTE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{NOTDQUOTE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PTICKED
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PTICKED"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PTICKED]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PTICKED},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/[^`]+/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/[^`]+/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PTICKED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PTICKED});
        %item = (__RULE__ => q{PTICKED});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/[^`]+/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PTICKED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:[^`]+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PTICKED},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/[^`]+/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PTICKED},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PTICKED},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PTICKED},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PTICKED},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PTICKED},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SLASHEDSQUOTE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SLASHEDSQUOTE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [SLASHEDSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{SLASHEDSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/\\\\'/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/\\\\'/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{SLASHEDSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SLASHEDSQUOTE});
        %item = (__RULE__ => q{SLASHEDSQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/\\\\'/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SLASHEDSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:\\')/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SLASHEDSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = "'"};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/\\\\'/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SLASHEDSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{SLASHEDSQUOTE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{SLASHEDSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SLASHEDSQUOTE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{SLASHEDSQUOTE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAMS
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PARAMS"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PARAMS]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PARAMS},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{PARAM});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [PARAM PARAMS]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PARAMS});
        %item = (__RULE__ => q{PARAMS});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PARAM]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PARAMS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAM($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PARAM]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PARAMS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PARAM]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PARAM}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PARAMS]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PARAMS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PARAMS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAMS($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PARAMS]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PARAMS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PARAMS]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PARAMS}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [$item{PARAM}, @{$item{PARAMS}}]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [PARAM PARAMS]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [PARAM]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{PARAMS});
        %item = (__RULE__ => q{PARAMS});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PARAM]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PARAMS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAM($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PARAM]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PARAMS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PARAM]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PARAM}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [$item{PARAM}]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [PARAM]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PARAMS},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PARAMS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PARAMS},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PARAMS},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::EOF
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"EOF"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [EOF]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{EOF},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/^\\Z/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{EOF},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{EOF});
        %item = (__RULE__ => q{EOF});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{EOF},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:^\Z)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{EOF},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{EOF},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{EOF},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{EOF},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{EOF},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SCEN
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SCEN"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [SCEN]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{SCEN},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{LINE});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [LINE SCEN]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SCEN});
        %item = (__RULE__ => q{SCEN});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [LINE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{SCEN},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::LINE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [LINE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{SCEN},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [LINE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{LINE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [SCEN]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{SCEN},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SCEN})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SCEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [SCEN]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{SCEN},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [SCEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SCEN}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [@{$item{LINE}},@{$item{SCEN}}]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [LINE SCEN]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [LINE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{SCEN});
        %item = (__RULE__ => q{SCEN});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [LINE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{SCEN},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::LINE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [LINE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{SCEN},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [LINE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{LINE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [@{$item{LINE}}]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [LINE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{SCEN},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{SCEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SCEN},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{SCEN},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PVALUE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PVALUE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PVALUE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PVALUE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/'/, or /"/, or /`/, or PNOTQUOTED});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/'/ PSQUOTE /'/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PVALUE});
        %item = (__RULE__ => q{PVALUE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/'/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:')/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PVALUE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PSQUOTE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PSQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PSQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PVALUE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PSQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PSQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/'/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/'/})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:')/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN2__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{PSQUOTE}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/'/ PSQUOTE /'/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/"/ PDQUOTE /"/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{PVALUE});
        %item = (__RULE__ => q{PVALUE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/"/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:")/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PDQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PVALUE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PDQUOTE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PDQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PDQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PVALUE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PDQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PDQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/"/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/"/})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:")/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN2__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{PDQUOTE}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/"/ PDQUOTE /"/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/`/ PTICKED /`/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{PVALUE});
        %item = (__RULE__ => q{PVALUE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/`/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:`)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PTICKED]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PVALUE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PTICKED})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PTICKED($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PTICKED]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PVALUE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PTICKED]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PTICKED}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/`/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/`/})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:`)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN2__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item[1].$item[2].$item[3]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/`/ PTICKED /`/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [PNOTQUOTED]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{PVALUE});
        %item = (__RULE__ => q{PVALUE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PNOTQUOTED]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PVALUE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PNOTQUOTED($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PNOTQUOTED]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PVALUE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PNOTQUOTED]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PNOTQUOTED}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{PNOTQUOTED}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [PNOTQUOTED]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PVALUE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PVALUE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PVALUE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PVALUE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::COMMENT
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"COMMENT"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [COMMENT]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{COMMENT},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/#[^\\n]*/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/#[^\\n]*/]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{COMMENT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{COMMENT});
        %item = (__RULE__ => q{COMMENT});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/#[^\\n]*/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{COMMENT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:#[^\n]*)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{COMMENT},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = ''};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/#[^\\n]*/]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{COMMENT},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{COMMENT},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{COMMENT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{COMMENT},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{COMMENT},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PARAM
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PARAM"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PARAM]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PARAM},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{PNAME});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {
        local $skip = defined($skip) ? $skip : $Parse::RecDescent::_Runtime::skip;
        Parse::RecDescent::_Runtime::_trace(q{Trying production: [PNAME '=' <skip: qr//> PVALUE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PARAM});
        %item = (__RULE__ => q{PARAM});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PARAM},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PARAM},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: ['=']},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{'='})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A\=/)
        {
            $text = $lastsep . $text if defined $lastsep;

            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(qq{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                            if defined $::RD_TRACE;
            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                            if defined $::RD_TRACE;
        push @item, $item{__STRING1__}=$current_match;




        Parse::RecDescent::_Runtime::_trace(q{Trying directive: [<skip: qr//>]},
                    Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $_tok = do { my $oldskip = $skip; $skip= qr//; $oldskip };
        if (defined($_tok))
        {
            Parse::RecDescent::_Runtime::_trace(q{>>Matched directive<< (return value: [}
                        . $_tok . q{])},
                        Parse::RecDescent::_Runtime::_tracefirst($text))
                            if defined $::RD_TRACE;
        }
        else
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match directive>>},
                        Parse::RecDescent::_Runtime::_tracefirst($text))
                            if defined $::RD_TRACE;
        }

        last unless defined $_tok;
        push @item, $item{__DIRECTIVE1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PVALUE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PARAM},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PVALUE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PVALUE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PVALUE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PARAM},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PVALUE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PVALUE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{PNAME}.'='.$item{PVALUE}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [PNAME '=' <skip: qr//> PVALUE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PARAM},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PARAM},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PARAM},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PARAM},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::TBNAME
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"TBNAME"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [TBNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{TBNAME},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/::/, or BNAME});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/::/ BNAME]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{TBNAME});
        %item = (__RULE__ => q{TBNAME});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/::/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:::)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [BNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{TBNAME},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{BNAME})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [BNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{TBNAME},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [BNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{BNAME}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/::/ BNAME]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [BNAME]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{TBNAME});
        %item = (__RULE__ => q{TBNAME});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [BNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{TBNAME},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [BNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{TBNAME},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [BNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = "Treex::Block::$item{BNAME}"};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [BNAME]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{TBNAME},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{TBNAME},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{TBNAME},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{TBNAME},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PSQUOTE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PSQUOTE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [PSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{PSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{NOTSQUOTE});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [NOTSQUOTE SLASHEDSQUOTE PSQUOTE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PSQUOTE});
        %item = (__RULE__ => q{PSQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [NOTSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::NOTSQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [NOTSQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PSQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [NOTSQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{NOTSQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [SLASHEDSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SLASHEDSQUOTE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SLASHEDSQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [SLASHEDSQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PSQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [SLASHEDSQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SLASHEDSQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [PSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{PSQUOTE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::PSQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [PSQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PSQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [PSQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PSQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{NOTSQUOTE}.$item{SLASHEDSQUOTE}.$item{PSQUOTE}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [NOTSQUOTE SLASHEDSQUOTE PSQUOTE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [NOTSQUOTE]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{PSQUOTE});
        %item = (__RULE__ => q{PSQUOTE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [NOTSQUOTE]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{PSQUOTE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::NOTSQUOTE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [NOTSQUOTE]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{PSQUOTE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [NOTSQUOTE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{NOTSQUOTE}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [NOTSQUOTE]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{PSQUOTE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{PSQUOTE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PSQUOTE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{PSQUOTE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::startrule
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"startrule"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [startrule]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{startrule},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{SCEN});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [SCEN EOF]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{startrule},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{startrule});
        %item = (__RULE__ => q{startrule});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [SCEN]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{startrule},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SCEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [SCEN]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{startrule},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [SCEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{startrule},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SCEN}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [EOF]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{startrule},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{EOF})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::EOF($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [EOF]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{startrule},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [EOF]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{startrule},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{EOF}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{startrule},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = $item{SCEN}};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [SCEN EOF]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{startrule},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{startrule},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{startrule},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{startrule},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{startrule},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::SCENMODULE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SCENMODULE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [SCENMODULE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{SCENMODULE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{/Scen::/});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [/Scen::/ BNAME]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{SCENMODULE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SCENMODULE});
        %item = (__RULE__ => q{SCENMODULE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [/Scen::/]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCENMODULE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:Scen::)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [BNAME]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{SCENMODULE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{BNAME})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BNAME($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [BNAME]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{SCENMODULE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [BNAME]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCENMODULE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BNAME}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCENMODULE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do { $return = "Treex::Scen::$item{BNAME}"};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [/Scen::/ BNAME]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{SCENMODULE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{SCENMODULE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{SCENMODULE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SCENMODULE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{SCENMODULE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::LINE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"LINE"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [LINE]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{LINE},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{BLOCK, or COMMENT});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [BLOCK COMMENT]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{LINE});
        %item = (__RULE__ => q{LINE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [BLOCK]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{LINE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BLOCK($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [BLOCK]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{LINE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [BLOCK]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BLOCK}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [COMMENT]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{LINE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{COMMENT})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::COMMENT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [COMMENT]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{LINE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [COMMENT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{COMMENT}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [@{$item{BLOCK}}]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [BLOCK COMMENT]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [BLOCK]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{LINE});
        %item = (__RULE__ => q{LINE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [BLOCK]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{LINE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::BLOCK($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [BLOCK]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{LINE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [BLOCK]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BLOCK}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = [@{$item{BLOCK}}]};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [BLOCK]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [COMMENT]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{LINE});
        %item = (__RULE__ => q{LINE});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying subrule: [COMMENT]},
                  Parse::RecDescent::_Runtime::_tracefirst($text),
                  q{LINE},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::COMMENT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {

            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match subrule: [COMMENT]>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text),
                          q{LINE},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched subrule: [COMMENT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{COMMENT}} = $_tok;
        push @item, $_tok;

        }

        Parse::RecDescent::_Runtime::_trace(q{Trying action},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;


        $_tok = ($_noactions) ? 0 : do {$return = []};
        unless (defined $_tok)
        {
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_Runtime::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [COMMENT]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{LINE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{LINE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{LINE},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{LINE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser::EMPTY
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"EMPTY"};

    Parse::RecDescent::_Runtime::_trace(q{Trying rule: [EMPTY]},
                  Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                  q{EMPTY},
                  $tracelevel)
                    if defined $::RD_TRACE;


    my $err_at = @{$thisparser->{errors}};

    my $score;
    my $score_return;
    my $_tok;
    my $return = undef;
    my $_matched=0;
    my $commit=0;
    my @item = ();
    my %item = ();
    my $repeating =  $_[2];
    my $_noactions = $_[3];
    my @arg =    defined $_[4] ? @{ &{$_[4]} } : ();
    my $_itempos = $_[5];
    my %arg =    ($#arg & 01) ? @arg : (@arg, undef);
    my $text;
    my $lastsep;
    my $current_match;
    my $expectation = new Parse::RecDescent::_Runtime::Expectation(q{//});
    $expectation->at($_[1]);

    my $thisline;
    tie $thisline, q{Parse::RecDescent::_Runtime::LineCounter}, \$text, $thisparser;



    while (!$_matched && !$commit)
    {

        Parse::RecDescent::_Runtime::_trace(q{Trying production: [//]},
                      Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                      q{EMPTY},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{EMPTY});
        %item = (__RULE__ => q{EMPTY});
        my $repcount = 0;


        Parse::RecDescent::_Runtime::_trace(q{Trying terminal: [//]}, Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{EMPTY},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{})->at($text);


        unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and   $text =~ m/\A(?:)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_Runtime::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_Runtime::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_Runtime::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;


        Parse::RecDescent::_Runtime::_trace(q{>>Matched production: [//]<<},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      q{EMPTY},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {


        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_Runtime::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_Runtime::_tracefirst($_[1]),
                     q{EMPTY},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Accepted scored production<<}, "",
                      q{EMPTY},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $return = $score_return;
    }
    splice @{$thisparser->{errors}}, $err_at;
    $return = $item[$#item] unless defined $return;
    if (defined $::RD_TRACE)
    {
        Parse::RecDescent::_Runtime::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{EMPTY},
                      $tracelevel);
        Parse::RecDescent::_Runtime::_trace(q{(consumed: [} .
                      Parse::RecDescent::_Runtime::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_Runtime::_tracefirst($text),
                      , q{EMPTY},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}
}
package Treex::Core::ScenarioParser; sub new { my $self = bless( {
                 '_AUTOTREE' => undef,
                 'namespace' => 'Parse::RecDescent::_Runtime::Treex::Core::ScenarioParser',
                 'localvars' => '',
                 '_check' => {
                               'thisoffset' => '',
                               'thiscolumn' => '',
                               'itempos' => '',
                               'prevoffset' => '',
                               'prevline' => '',
                               'prevcolumn' => ''
                             },
                 '_AUTOACTION' => undef,
                 'startcode' => '',
                 'rules' => {
                              'PNOTQUOTED' => bless( {
                                                       'calls' => [
                                                                    'EMPTY'
                                                                  ],
                                                       'impcount' => 0,
                                                       'line' => 90,
                                                       'vars' => '',
                                                       'changed' => 0,
                                                       'opcount' => 0,
                                                       'prods' => [
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 90,
                                                                                                   'description' => '/\\\\S+/',
                                                                                                   'ldelim' => '/',
                                                                                                   'pattern' => '\\S+',
                                                                                                   'rdelim' => '/',
                                                                                                   'mod' => '',
                                                                                                   'lookahead' => 0,
                                                                                                   'hashname' => '__PATTERN1__'
                                                                                                 }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                          bless( {
                                                                                                   'line' => 90,
                                                                                                   'lookahead' => 0,
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{$return = $item[1]}'
                                                                                                 }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                        ],
                                                                             'strcount' => 0,
                                                                             'actcount' => 1,
                                                                             'line' => undef,
                                                                             'error' => undef,
                                                                             'uncommit' => undef,
                                                                             'patcount' => 1,
                                                                             'number' => 0,
                                                                             'dircount' => 0
                                                                           }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                    bless( {
                                                                             'dircount' => 0,
                                                                             'number' => 1,
                                                                             'patcount' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'error' => undef,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'subrule' => 'EMPTY',
                                                                                                   'matchrule' => 0,
                                                                                                   'line' => 91
                                                                                                 }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'code' => '{$return = \'\'}',
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'line' => 91
                                                                                                 }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                        ]
                                                                           }, 'Parse::RecDescent::_Runtime::Production' )
                                                                  ],
                                                       'name' => 'PNOTQUOTED'
                                                     }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'SPACE' => bless( {
                                                  'prods' => [
                                                               bless( {
                                                                        'dircount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 1,
                                                                        'actcount' => 1,
                                                                        'line' => undef,
                                                                        'error' => undef,
                                                                        'strcount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'lookahead' => 0,
                                                                                              'rdelim' => '/',
                                                                                              'mod' => '',
                                                                                              'description' => '/\\\\s+/',
                                                                                              'pattern' => '\\s+',
                                                                                              'ldelim' => '/',
                                                                                              'line' => 94
                                                                                            }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{$return = $item[1]}',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'line' => 94
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::_Runtime::Production' )
                                                             ],
                                                  'name' => 'SPACE',
                                                  'changed' => 0,
                                                  'opcount' => 0,
                                                  'vars' => '',
                                                  'calls' => [],
                                                  'impcount' => 0,
                                                  'line' => 94
                                                }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PDQUOTE' => bless( {
                                                    'changed' => 0,
                                                    'opcount' => 0,
                                                    'name' => 'PDQUOTE',
                                                    'prods' => [
                                                                 bless( {
                                                                          'actcount' => 1,
                                                                          'line' => undef,
                                                                          'error' => undef,
                                                                          'strcount' => 0,
                                                                          'number' => 0,
                                                                          'dircount' => 0,
                                                                          'uncommit' => undef,
                                                                          'patcount' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'argcode' => undef,
                                                                                                'implicit' => undef,
                                                                                                'subrule' => 'NOTDQUOTE',
                                                                                                'matchrule' => 0,
                                                                                                'line' => 85
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                       bless( {
                                                                                                'subrule' => 'SLASHEDDQUOTE',
                                                                                                'implicit' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'argcode' => undef,
                                                                                                'line' => 85,
                                                                                                'matchrule' => 0
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                       bless( {
                                                                                                'matchrule' => 0,
                                                                                                'line' => 85,
                                                                                                'argcode' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'implicit' => undef,
                                                                                                'subrule' => 'PDQUOTE'
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                       bless( {
                                                                                                'line' => 85,
                                                                                                'code' => '{$return = $item{NOTDQUOTE}.$item{SLASHEDDQUOTE}.$item{PDQUOTE}}',
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                     ]
                                                                        }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                 bless( {
                                                                          'dircount' => 0,
                                                                          'number' => 1,
                                                                          'patcount' => 0,
                                                                          'uncommit' => undef,
                                                                          'error' => undef,
                                                                          'line' => undef,
                                                                          'actcount' => 0,
                                                                          'strcount' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'line' => 86,
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'NOTDQUOTE',
                                                                                                'implicit' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'argcode' => undef
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' )
                                                                                     ]
                                                                        }, 'Parse::RecDescent::_Runtime::Production' )
                                                               ],
                                                    'line' => 85,
                                                    'impcount' => 0,
                                                    'calls' => [
                                                                 'NOTDQUOTE',
                                                                 'SLASHEDDQUOTE',
                                                                 'PDQUOTE'
                                                               ],
                                                    'vars' => ''
                                                  }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'BNAME' => bless( {
                                                  'opcount' => 0,
                                                  'changed' => 0,
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'description' => '/[A-Z]\\\\w*::/',
                                                                                              'pattern' => '[A-Z]\\w*::',
                                                                                              'ldelim' => '/',
                                                                                              'line' => 71,
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'lookahead' => 0,
                                                                                              'rdelim' => '/',
                                                                                              'mod' => ''
                                                                                            }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                     bless( {
                                                                                              'subrule' => 'BNAME',
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef,
                                                                                              'line' => 71,
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'code' => '{$return = $item[1].$item[2]}',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 71
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ],
                                                                        'uncommit' => undef,
                                                                        'patcount' => 1,
                                                                        'number' => 0,
                                                                        'dircount' => 0,
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef
                                                                      }, 'Parse::RecDescent::_Runtime::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => '[A-Z]\\w*',
                                                                                              'description' => '/[A-Z]\\\\w*/',
                                                                                              'line' => 72,
                                                                                              'lookahead' => 0,
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'mod' => '',
                                                                                              'rdelim' => '/'
                                                                                            }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                     bless( {
                                                                                              'line' => 72,
                                                                                              'code' => '{$return = $item[1]}',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'number' => 1,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 1,
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'strcount' => 0
                                                                      }, 'Parse::RecDescent::_Runtime::Production' )
                                                             ],
                                                  'name' => 'BNAME',
                                                  'impcount' => 0,
                                                  'calls' => [
                                                               'BNAME'
                                                             ],
                                                  'line' => 70,
                                                  'vars' => ''
                                                }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PNAME' => bless( {
                                                  'changed' => 0,
                                                  'opcount' => 0,
                                                  'prods' => [
                                                               bless( {
                                                                        'uncommit' => undef,
                                                                        'patcount' => 1,
                                                                        'number' => 0,
                                                                        'dircount' => 0,
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'description' => '/\\\\w+/',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => '\\w+',
                                                                                              'line' => 76,
                                                                                              'lookahead' => 0,
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'rdelim' => '/',
                                                                                              'mod' => ''
                                                                                            }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                     bless( {
                                                                                              'line' => 76,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{$return = $item[1]}',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::_Runtime::Production' )
                                                             ],
                                                  'name' => 'PNAME',
                                                  'calls' => [],
                                                  'impcount' => 0,
                                                  'line' => 76,
                                                  'vars' => ''
                                                }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'NOTSQUOTE' => bless( {
                                                      'impcount' => 0,
                                                      'calls' => [],
                                                      'line' => 83,
                                                      'vars' => '',
                                                      'opcount' => 0,
                                                      'changed' => 0,
                                                      'prods' => [
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'line' => 83,
                                                                                                  'description' => '/[^\']*[^\'\\\\\\\\]/',
                                                                                                  'ldelim' => '/',
                                                                                                  'pattern' => '[^\']*[^\'\\\\]',
                                                                                                  'rdelim' => '/',
                                                                                                  'mod' => '',
                                                                                                  'lookahead' => 0,
                                                                                                  'hashname' => '__PATTERN1__'
                                                                                                }, 'Parse::RecDescent::_Runtime::Token' )
                                                                                       ],
                                                                            'strcount' => 0,
                                                                            'actcount' => 0,
                                                                            'error' => undef,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'patcount' => 1,
                                                                            'number' => 0,
                                                                            'dircount' => 0
                                                                          }, 'Parse::RecDescent::_Runtime::Production' )
                                                                 ],
                                                      'name' => 'NOTSQUOTE'
                                                    }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'INCLUDE' => bless( {
                                                    'opcount' => 0,
                                                    'changed' => 0,
                                                    'prods' => [
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'hashname' => '__PATTERN1__',
                                                                                                'mod' => '',
                                                                                                'rdelim' => '/',
                                                                                                'ldelim' => '/',
                                                                                                'pattern' => '\\/\\S+\\.scen',
                                                                                                'description' => '/\\\\/\\\\S+\\\\.scen/',
                                                                                                'line' => 61
                                                                                              }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                       bless( {
                                                                                                'line' => 61,
                                                                                                'lookahead' => 0,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{$return = $item[1]}'
                                                                                              }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                     ],
                                                                          'strcount' => 0,
                                                                          'line' => undef,
                                                                          'error' => undef,
                                                                          'actcount' => 1,
                                                                          'patcount' => 1,
                                                                          'uncommit' => undef,
                                                                          'dircount' => 0,
                                                                          'number' => 0
                                                                        }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'description' => '/[^\\\\/#]\\\\S+\\\\.scen/',
                                                                                                'pattern' => '[^\\/#]\\S+\\.scen',
                                                                                                'ldelim' => '/',
                                                                                                'line' => 62,
                                                                                                'hashname' => '__PATTERN1__',
                                                                                                'lookahead' => 0,
                                                                                                'rdelim' => '/',
                                                                                                'mod' => ''
                                                                                              }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                       bless( {
                                                                                                'line' => 62,
                                                                                                'lookahead' => 0,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{   my $from_file = $arg[0];
                                                                                                        if (length $from_file) {
                                                                                                                $return = dirname($from_file) . "/$item[1]";
                                                                                                        } else {
                                                                                                                $return = "./$item[1]";
                                                                                                        }
                                                                                                }'
                                                                                              }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                     ],
                                                                          'error' => undef,
                                                                          'line' => undef,
                                                                          'actcount' => 1,
                                                                          'strcount' => 0,
                                                                          'number' => 1,
                                                                          'dircount' => 0,
                                                                          'patcount' => 1,
                                                                          'uncommit' => undef
                                                                        }, 'Parse::RecDescent::_Runtime::Production' )
                                                               ],
                                                    'name' => 'INCLUDE',
                                                    'impcount' => 0,
                                                    'calls' => [],
                                                    'line' => 61,
                                                    'vars' => ''
                                                  }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'BLOCK' => bless( {
                                                  'vars' => '',
                                                  'line' => 16,
                                                  'impcount' => 0,
                                                  'calls' => [
                                                               'INCLUDE',
                                                               'SCENMODULE',
                                                               'PARAMS',
                                                               'TBNAME'
                                                             ],
                                                  'name' => 'BLOCK',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 16,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'INCLUDE',
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'line' => 16,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{
                                                                                                        my $included = read_file( $item{INCLUDE}, binmode => \':utf8\' );
                                                                                                        my $result = $thisparser->startrule( $included, 1, $item{INCLUDE} );
                                                                                                        if (defined $result and ref $result eq \'ARRAY\') {
                                                                                                                $return = [@$result];
                                                                                                        } else {
                                                                                                                $return = undef;
                                                                                                        }
                                                                                                }',
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ],
                                                                        'strcount' => 0,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'actcount' => 1,
                                                                        'patcount' => 0,
                                                                        'uncommit' => undef,
                                                                        'dircount' => 0,
                                                                        'number' => 0
                                                                      }, 'Parse::RecDescent::_Runtime::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 25,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'SCENMODULE',
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'subrule' => 'PARAMS',
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef,
                                                                                              'line' => 25,
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{
                                                                                                        my $modulename = $item{SCENMODULE};
                                                                                                        eval "use $modulename; 1;" or die "Can\'t use $modulename !\\n$@\\n";
                                                                                                        my %params = map {my ($name,$value) = split /=/, $_, 2; ($name, $value)} @{$item{PARAMS}};
                                                                                                        my $scenmod = $modulename->new(\\%params);
                                                                                                        my $string = $scenmod->get_scenario_string();
                                                                                                        my $result = $thisparser->startrule( $string, 0, \'\' );
                                                                                                        if (defined $result and ref $result eq \'ARRAY\') {
                                                                                                                $return = [@$result];
                                                                                                        } else {
                                                                                                                log_fatal "Syntax error in \'$modulename\' scenario:\\n<BEGIN SCENARIO>\\n$string\\n<END SCENARIO>";
                                                                                                        }
                                                                                                }',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 25
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ],
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'number' => 1
                                                                      }, 'Parse::RecDescent::_Runtime::Production' ),
                                                               bless( {
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'number' => 2,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'matchrule' => 0,
                                                                                              'line' => 38,
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef,
                                                                                              'subrule' => 'SCENMODULE'
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'code' => '{
                                                                                                        my $modulename = $item{SCENMODULE};
                                                                                                        eval "use $modulename; 1;" or die "Can\'t use $modulename !\\n$@\\n";
                                                                                                        my $scenmod = $modulename->new();
                                                                                                        my $string = $scenmod->get_scenario_string();
                                                                                                        my $result = $thisparser->startrule( $string, 0, \'\' );
                                                                                                        if (defined $result and ref $result eq \'ARRAY\') {
                                                                                                                $return = [@$result];
                                                                                                        } else {
                                                                                                                log_fatal "Syntax error in \'$modulename\' scenario:\\n<BEGIN SCENARIO>\\n$string\\n<END SCENARIO>";
                                                                                                        }
                                                                                                }',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 38
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::_Runtime::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 50,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'TBNAME',
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'matchrule' => 0,
                                                                                              'line' => 50,
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'subrule' => 'PARAMS'
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'code' => '{$return = [{
                                                                                                                block_name=>$item{TBNAME},
                                                                                                                block_parameters=>$item{PARAMS},
                                                                                                        }]
                                                                                                }',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 50
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ],
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'number' => 3
                                                                      }, 'Parse::RecDescent::_Runtime::Production' ),
                                                               bless( {
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'line' => undef,
                                                                        'error' => undef,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'number' => 4,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef,
                                                                                              'subrule' => 'TBNAME',
                                                                                              'matchrule' => 0,
                                                                                              'line' => 55
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{$return = [{
                                                                                                                block_name=>$item{TBNAME},
                                                                                                                block_parameters=>[],
                                                                                                        }]
                                                                                                }',
                                                                                              'line' => 55
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::_Runtime::Production' )
                                                             ],
                                                  'opcount' => 0,
                                                  'changed' => 0
                                                }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'SLASHEDDQUOTE' => bless( {
                                                          'opcount' => 0,
                                                          'changed' => 0,
                                                          'name' => 'SLASHEDDQUOTE',
                                                          'prods' => [
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'description' => '/\\\\\\\\"/',
                                                                                                      'ldelim' => '/',
                                                                                                      'pattern' => '\\\\"',
                                                                                                      'line' => 88,
                                                                                                      'lookahead' => 0,
                                                                                                      'hashname' => '__PATTERN1__',
                                                                                                      'rdelim' => '/',
                                                                                                      'mod' => ''
                                                                                                    }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                             bless( {
                                                                                                      'line' => 88,
                                                                                                      'lookahead' => 0,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{$return = \'"\'}'
                                                                                                    }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                           ],
                                                                                'uncommit' => undef,
                                                                                'patcount' => 1,
                                                                                'dircount' => 0,
                                                                                'number' => 0,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1,
                                                                                'line' => undef,
                                                                                'error' => undef
                                                                              }, 'Parse::RecDescent::_Runtime::Production' )
                                                                     ],
                                                          'line' => 88,
                                                          'impcount' => 0,
                                                          'calls' => [],
                                                          'vars' => ''
                                                        }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'NOTDQUOTE' => bless( {
                                                      'calls' => [],
                                                      'impcount' => 0,
                                                      'line' => 87,
                                                      'vars' => '',
                                                      'changed' => 0,
                                                      'opcount' => 0,
                                                      'prods' => [
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'mod' => '',
                                                                                                  'rdelim' => '/',
                                                                                                  'lookahead' => 0,
                                                                                                  'hashname' => '__PATTERN1__',
                                                                                                  'line' => 87,
                                                                                                  'ldelim' => '/',
                                                                                                  'pattern' => '[^"]*[^"\\\\]',
                                                                                                  'description' => '/[^"]*[^"\\\\\\\\]/'
                                                                                                }, 'Parse::RecDescent::_Runtime::Token' )
                                                                                       ],
                                                                            'error' => undef,
                                                                            'line' => undef,
                                                                            'actcount' => 0,
                                                                            'strcount' => 0,
                                                                            'dircount' => 0,
                                                                            'number' => 0,
                                                                            'patcount' => 1,
                                                                            'uncommit' => undef
                                                                          }, 'Parse::RecDescent::_Runtime::Production' )
                                                                 ],
                                                      'name' => 'NOTDQUOTE'
                                                    }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PTICKED' => bless( {
                                                    'vars' => '',
                                                    'line' => 92,
                                                    'calls' => [],
                                                    'impcount' => 0,
                                                    'name' => 'PTICKED',
                                                    'prods' => [
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'line' => 92,
                                                                                                'description' => '/[^`]+/',
                                                                                                'pattern' => '[^`]+',
                                                                                                'ldelim' => '/',
                                                                                                'rdelim' => '/',
                                                                                                'mod' => '',
                                                                                                'hashname' => '__PATTERN1__',
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                       bless( {
                                                                                                'line' => 92,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{$return = $item[1]}',
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'number' => 0,
                                                                          'uncommit' => undef,
                                                                          'patcount' => 1,
                                                                          'actcount' => 1,
                                                                          'line' => undef,
                                                                          'error' => undef,
                                                                          'strcount' => 0
                                                                        }, 'Parse::RecDescent::_Runtime::Production' )
                                                               ],
                                                    'changed' => 0,
                                                    'opcount' => 0
                                                  }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'SLASHEDSQUOTE' => bless( {
                                                          'vars' => '',
                                                          'line' => 84,
                                                          'impcount' => 0,
                                                          'calls' => [],
                                                          'name' => 'SLASHEDSQUOTE',
                                                          'prods' => [
                                                                       bless( {
                                                                                'actcount' => 1,
                                                                                'line' => undef,
                                                                                'error' => undef,
                                                                                'strcount' => 0,
                                                                                'number' => 0,
                                                                                'dircount' => 0,
                                                                                'uncommit' => undef,
                                                                                'patcount' => 1,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'mod' => '',
                                                                                                      'rdelim' => '/',
                                                                                                      'hashname' => '__PATTERN1__',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 84,
                                                                                                      'pattern' => '\\\\\'',
                                                                                                      'ldelim' => '/',
                                                                                                      'description' => '/\\\\\\\\\'/'
                                                                                                    }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                             bless( {
                                                                                                      'line' => 84,
                                                                                                      'lookahead' => 0,
                                                                                                      'code' => '{$return = "\'"}',
                                                                                                      'hashname' => '__ACTION1__'
                                                                                                    }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::_Runtime::Production' )
                                                                     ],
                                                          'changed' => 0,
                                                          'opcount' => 0
                                                        }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PARAMS' => bless( {
                                                   'impcount' => 0,
                                                   'calls' => [
                                                                'PARAM',
                                                                'PARAMS'
                                                              ],
                                                   'line' => 73,
                                                   'vars' => '',
                                                   'changed' => 0,
                                                   'opcount' => 0,
                                                   'prods' => [
                                                                bless( {
                                                                         'line' => undef,
                                                                         'error' => undef,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'dircount' => 0,
                                                                         'number' => 0,
                                                                         'patcount' => 0,
                                                                         'uncommit' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 73,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'PARAM',
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'subrule' => 'PARAMS',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 73
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{$return = [$item{PARAM}, @{$item{PARAMS}}]}',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'line' => 73
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'line' => 74,
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'PARAM'
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{$return = [$item{PARAM}]}',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 74
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ],
                                                                         'line' => undef,
                                                                         'error' => undef,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'number' => 1,
                                                                         'dircount' => 0,
                                                                         'patcount' => 0,
                                                                         'uncommit' => undef
                                                                       }, 'Parse::RecDescent::_Runtime::Production' )
                                                              ],
                                                   'name' => 'PARAMS'
                                                 }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'EOF' => bless( {
                                                'impcount' => 0,
                                                'calls' => [],
                                                'line' => 15,
                                                'vars' => '',
                                                'opcount' => 0,
                                                'changed' => 0,
                                                'prods' => [
                                                             bless( {
                                                                      'actcount' => 0,
                                                                      'line' => undef,
                                                                      'error' => undef,
                                                                      'strcount' => 0,
                                                                      'number' => 0,
                                                                      'dircount' => 0,
                                                                      'uncommit' => undef,
                                                                      'patcount' => 1,
                                                                      'items' => [
                                                                                   bless( {
                                                                                            'lookahead' => 0,
                                                                                            'hashname' => '__PATTERN1__',
                                                                                            'rdelim' => '/',
                                                                                            'mod' => '',
                                                                                            'description' => '/^\\\\Z/',
                                                                                            'ldelim' => '/',
                                                                                            'pattern' => '^\\Z',
                                                                                            'line' => 15
                                                                                          }, 'Parse::RecDescent::_Runtime::Token' )
                                                                                 ]
                                                                    }, 'Parse::RecDescent::_Runtime::Production' )
                                                           ],
                                                'name' => 'EOF'
                                              }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'SCEN' => bless( {
                                                 'vars' => '',
                                                 'calls' => [
                                                              'LINE',
                                                              'SCEN'
                                                            ],
                                                 'impcount' => 0,
                                                 'line' => 10,
                                                 'prods' => [
                                                              bless( {
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'subrule' => 'LINE',
                                                                                             'implicit' => undef,
                                                                                             'lookahead' => 0,
                                                                                             'argcode' => undef,
                                                                                             'line' => 10,
                                                                                             'matchrule' => 0
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'matchrule' => 0,
                                                                                             'line' => 10,
                                                                                             'argcode' => undef,
                                                                                             'lookahead' => 0,
                                                                                             'implicit' => undef,
                                                                                             'subrule' => 'SCEN'
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'line' => 10,
                                                                                             'lookahead' => 0,
                                                                                             'hashname' => '__ACTION1__',
                                                                                             'code' => '{$return = [@{$item{LINE}},@{$item{SCEN}}]}'
                                                                                           }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                  ],
                                                                       'line' => undef,
                                                                       'error' => undef,
                                                                       'actcount' => 1,
                                                                       'strcount' => 0,
                                                                       'dircount' => 0,
                                                                       'number' => 0,
                                                                       'patcount' => 0,
                                                                       'uncommit' => undef
                                                                     }, 'Parse::RecDescent::_Runtime::Production' ),
                                                              bless( {
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'matchrule' => 0,
                                                                                             'line' => 11,
                                                                                             'implicit' => undef,
                                                                                             'argcode' => undef,
                                                                                             'lookahead' => 0,
                                                                                             'subrule' => 'LINE'
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'line' => 11,
                                                                                             'lookahead' => 0,
                                                                                             'hashname' => '__ACTION1__',
                                                                                             'code' => '{$return = [@{$item{LINE}}]}'
                                                                                           }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                  ],
                                                                       'strcount' => 0,
                                                                       'actcount' => 1,
                                                                       'line' => undef,
                                                                       'error' => undef,
                                                                       'uncommit' => undef,
                                                                       'patcount' => 0,
                                                                       'number' => 1,
                                                                       'dircount' => 0
                                                                     }, 'Parse::RecDescent::_Runtime::Production' )
                                                            ],
                                                 'name' => 'SCEN',
                                                 'changed' => 0,
                                                 'opcount' => 0
                                               }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PVALUE' => bless( {
                                                   'prods' => [
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'mod' => '',
                                                                                               'rdelim' => '/',
                                                                                               'lookahead' => 0,
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'line' => 77,
                                                                                               'ldelim' => '/',
                                                                                               'pattern' => '\'',
                                                                                               'description' => '/\'/'
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'line' => 77,
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'PSQUOTE'
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'ldelim' => '/',
                                                                                               'pattern' => '\'',
                                                                                               'description' => '/\'/',
                                                                                               'line' => 77,
                                                                                               'lookahead' => 0,
                                                                                               'hashname' => '__PATTERN2__',
                                                                                               'mod' => '',
                                                                                               'rdelim' => '/'
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'code' => '{$return = $item{PSQUOTE}}',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 77
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'number' => 0,
                                                                         'uncommit' => undef,
                                                                         'patcount' => 2,
                                                                         'actcount' => 1,
                                                                         'error' => undef,
                                                                         'line' => undef,
                                                                         'strcount' => 0
                                                                       }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'pattern' => '"',
                                                                                               'ldelim' => '/',
                                                                                               'description' => '/"/',
                                                                                               'line' => 78,
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'rdelim' => '/'
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'line' => 78,
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'subrule' => 'PDQUOTE'
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 78,
                                                                                               'pattern' => '"',
                                                                                               'ldelim' => '/',
                                                                                               'description' => '/"/',
                                                                                               'mod' => '',
                                                                                               'rdelim' => '/',
                                                                                               'hashname' => '__PATTERN2__',
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'line' => 78,
                                                                                               'lookahead' => 0,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{$return = $item{PDQUOTE}}'
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ],
                                                                         'actcount' => 1,
                                                                         'line' => undef,
                                                                         'error' => undef,
                                                                         'strcount' => 0,
                                                                         'dircount' => 0,
                                                                         'number' => 1,
                                                                         'uncommit' => undef,
                                                                         'patcount' => 2
                                                                       }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                bless( {
                                                                         'uncommit' => undef,
                                                                         'patcount' => 2,
                                                                         'dircount' => 0,
                                                                         'number' => 2,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'error' => undef,
                                                                         'line' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 79,
                                                                                               'pattern' => '`',
                                                                                               'ldelim' => '/',
                                                                                               'description' => '/`/',
                                                                                               'mod' => '',
                                                                                               'rdelim' => '/',
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'subrule' => 'PTICKED',
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'line' => 79,
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'hashname' => '__PATTERN2__',
                                                                                               'rdelim' => '/',
                                                                                               'mod' => '',
                                                                                               'description' => '/`/',
                                                                                               'ldelim' => '/',
                                                                                               'pattern' => '`',
                                                                                               'line' => 79
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{$return = $item[1].$item[2].$item[3]}',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 79
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                bless( {
                                                                         'actcount' => 1,
                                                                         'error' => undef,
                                                                         'line' => undef,
                                                                         'strcount' => 0,
                                                                         'dircount' => 0,
                                                                         'number' => 3,
                                                                         'uncommit' => undef,
                                                                         'patcount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'subrule' => 'PNOTQUOTED',
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'line' => 80,
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'code' => '{$return = $item{PNOTQUOTED}}',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 80
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::_Runtime::Production' )
                                                              ],
                                                   'name' => 'PVALUE',
                                                   'changed' => 0,
                                                   'opcount' => 0,
                                                   'vars' => '',
                                                   'calls' => [
                                                                'PSQUOTE',
                                                                'PDQUOTE',
                                                                'PTICKED',
                                                                'PNOTQUOTED'
                                                              ],
                                                   'impcount' => 0,
                                                   'line' => 77
                                                 }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'COMMENT' => bless( {
                                                    'changed' => 0,
                                                    'opcount' => 0,
                                                    'prods' => [
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'hashname' => '__PATTERN1__',
                                                                                                'mod' => '',
                                                                                                'rdelim' => '/',
                                                                                                'ldelim' => '/',
                                                                                                'pattern' => '#[^\\n]*',
                                                                                                'description' => '/#[^\\\\n]*/',
                                                                                                'line' => 93
                                                                                              }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                       bless( {
                                                                                                'line' => 93,
                                                                                                'lookahead' => 0,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{$return = \'\'}'
                                                                                              }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                     ],
                                                                          'patcount' => 1,
                                                                          'uncommit' => undef,
                                                                          'number' => 0,
                                                                          'dircount' => 0,
                                                                          'strcount' => 0,
                                                                          'error' => undef,
                                                                          'line' => undef,
                                                                          'actcount' => 1
                                                                        }, 'Parse::RecDescent::_Runtime::Production' )
                                                               ],
                                                    'name' => 'COMMENT',
                                                    'calls' => [],
                                                    'impcount' => 0,
                                                    'line' => 93,
                                                    'vars' => ''
                                                  }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PARAM' => bless( {
                                                  'vars' => '',
                                                  'line' => 75,
                                                  'calls' => [
                                                               'PNAME',
                                                               'PVALUE'
                                                             ],
                                                  'impcount' => 0,
                                                  'name' => 'PARAM',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'subrule' => 'PNAME',
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef,
                                                                                              'line' => 75,
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'line' => 75,
                                                                                              'description' => '\'=\'',
                                                                                              'lookahead' => 0,
                                                                                              'hashname' => '__STRING1__',
                                                                                              'pattern' => '='
                                                                                            }, 'Parse::RecDescent::_Runtime::Literal' ),
                                                                                     bless( {
                                                                                              'name' => '<skip: qr//>',
                                                                                              'hashname' => '__DIRECTIVE1__',
                                                                                              'code' => 'my $oldskip = $skip; $skip= qr//; $oldskip',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 75
                                                                                            }, 'Parse::RecDescent::_Runtime::Directive' ),
                                                                                     bless( {
                                                                                              'line' => 75,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'PVALUE',
                                                                                              'implicit' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => undef
                                                                                            }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                     bless( {
                                                                                              'line' => 75,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{$return = $item{PNAME}.\'=\'.$item{PVALUE}}',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                   ],
                                                                        'actcount' => 1,
                                                                        'error' => undef,
                                                                        'line' => undef,
                                                                        'strcount' => 1,
                                                                        'number' => 0,
                                                                        'dircount' => 1,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 0
                                                                      }, 'Parse::RecDescent::_Runtime::Production' )
                                                             ],
                                                  'opcount' => 0,
                                                  'changed' => 0
                                                }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'TBNAME' => bless( {
                                                   'vars' => '',
                                                   'impcount' => 0,
                                                   'calls' => [
                                                                'BNAME'
                                                              ],
                                                   'line' => 69,
                                                   'prods' => [
                                                                bless( {
                                                                         'uncommit' => undef,
                                                                         'patcount' => 1,
                                                                         'number' => 0,
                                                                         'dircount' => 0,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'line' => undef,
                                                                         'error' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'description' => '/::/',
                                                                                               'pattern' => '::',
                                                                                               'ldelim' => '/',
                                                                                               'line' => 69,
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'lookahead' => 0,
                                                                                               'rdelim' => '/',
                                                                                               'mod' => ''
                                                                                             }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                      bless( {
                                                                                               'line' => 69,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'BNAME',
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 69,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{$return = $item{BNAME}}',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'subrule' => 'BNAME',
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 70,
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 70,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{$return = "Treex::Block::$item{BNAME}"}',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                    ],
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'line' => undef,
                                                                         'error' => undef,
                                                                         'uncommit' => undef,
                                                                         'patcount' => 0,
                                                                         'number' => 1,
                                                                         'dircount' => 0
                                                                       }, 'Parse::RecDescent::_Runtime::Production' )
                                                              ],
                                                   'name' => 'TBNAME',
                                                   'changed' => 0,
                                                   'opcount' => 0
                                                 }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'PSQUOTE' => bless( {
                                                    'prods' => [
                                                                 bless( {
                                                                          'patcount' => 0,
                                                                          'uncommit' => undef,
                                                                          'dircount' => 0,
                                                                          'number' => 0,
                                                                          'strcount' => 0,
                                                                          'line' => undef,
                                                                          'error' => undef,
                                                                          'actcount' => 1,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'implicit' => undef,
                                                                                                'argcode' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'subrule' => 'NOTSQUOTE',
                                                                                                'matchrule' => 0,
                                                                                                'line' => 81
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                       bless( {
                                                                                                'matchrule' => 0,
                                                                                                'line' => 81,
                                                                                                'argcode' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'implicit' => undef,
                                                                                                'subrule' => 'SLASHEDSQUOTE'
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                       bless( {
                                                                                                'line' => 81,
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'PSQUOTE',
                                                                                                'lookahead' => 0,
                                                                                                'argcode' => undef,
                                                                                                'implicit' => undef
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{$return = $item{NOTSQUOTE}.$item{SLASHEDSQUOTE}.$item{PSQUOTE}}',
                                                                                                'line' => 81
                                                                                              }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                     ]
                                                                        }, 'Parse::RecDescent::_Runtime::Production' ),
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'subrule' => 'NOTSQUOTE',
                                                                                                'argcode' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'implicit' => undef,
                                                                                                'line' => 82,
                                                                                                'matchrule' => 0
                                                                                              }, 'Parse::RecDescent::_Runtime::Subrule' )
                                                                                     ],
                                                                          'error' => undef,
                                                                          'line' => undef,
                                                                          'actcount' => 0,
                                                                          'strcount' => 0,
                                                                          'number' => 1,
                                                                          'dircount' => 0,
                                                                          'patcount' => 0,
                                                                          'uncommit' => undef
                                                                        }, 'Parse::RecDescent::_Runtime::Production' )
                                                               ],
                                                    'name' => 'PSQUOTE',
                                                    'changed' => 0,
                                                    'opcount' => 0,
                                                    'vars' => '',
                                                    'impcount' => 0,
                                                    'calls' => [
                                                                 'NOTSQUOTE',
                                                                 'SLASHEDSQUOTE',
                                                                 'PSQUOTE'
                                                               ],
                                                    'line' => 81
                                                  }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'startrule' => bless( {
                                                      'name' => 'startrule',
                                                      'prods' => [
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'line' => 9,
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'SCEN',
                                                                                                  'lookahead' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                         bless( {
                                                                                                  'line' => 9,
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'EOF',
                                                                                                  'argcode' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'code' => '{$return = $item{SCEN}}',
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'line' => 9
                                                                                                }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                       ],
                                                                            'actcount' => 1,
                                                                            'error' => undef,
                                                                            'line' => undef,
                                                                            'strcount' => 0,
                                                                            'dircount' => 0,
                                                                            'number' => 0,
                                                                            'uncommit' => undef,
                                                                            'patcount' => 0
                                                                          }, 'Parse::RecDescent::_Runtime::Production' )
                                                                 ],
                                                      'changed' => 0,
                                                      'opcount' => 0,
                                                      'vars' => '',
                                                      'line' => 9,
                                                      'impcount' => 0,
                                                      'calls' => [
                                                                   'SCEN',
                                                                   'EOF'
                                                                 ]
                                                    }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'SCENMODULE' => bless( {
                                                       'line' => 60,
                                                       'calls' => [
                                                                    'BNAME'
                                                                  ],
                                                       'impcount' => 0,
                                                       'vars' => '',
                                                       'changed' => 0,
                                                       'opcount' => 0,
                                                       'name' => 'SCENMODULE',
                                                       'prods' => [
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'description' => '/Scen::/',
                                                                                                   'ldelim' => '/',
                                                                                                   'pattern' => 'Scen::',
                                                                                                   'line' => 60,
                                                                                                   'lookahead' => 0,
                                                                                                   'hashname' => '__PATTERN1__',
                                                                                                   'rdelim' => '/',
                                                                                                   'mod' => ''
                                                                                                 }, 'Parse::RecDescent::_Runtime::Token' ),
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'line' => 60,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'subrule' => 'BNAME'
                                                                                                 }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                          bless( {
                                                                                                   'code' => '{ $return = "Treex::Scen::$item{BNAME}"}',
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 60
                                                                                                 }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                        ],
                                                                             'number' => 0,
                                                                             'dircount' => 0,
                                                                             'patcount' => 1,
                                                                             'uncommit' => undef,
                                                                             'error' => undef,
                                                                             'line' => undef,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0
                                                                           }, 'Parse::RecDescent::_Runtime::Production' )
                                                                  ]
                                                     }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'LINE' => bless( {
                                                 'prods' => [
                                                              bless( {
                                                                       'actcount' => 1,
                                                                       'line' => undef,
                                                                       'error' => undef,
                                                                       'strcount' => 0,
                                                                       'number' => 0,
                                                                       'dircount' => 0,
                                                                       'uncommit' => undef,
                                                                       'patcount' => 0,
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'line' => 12,
                                                                                             'matchrule' => 0,
                                                                                             'subrule' => 'BLOCK',
                                                                                             'implicit' => undef,
                                                                                             'lookahead' => 0,
                                                                                             'argcode' => undef
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'subrule' => 'COMMENT',
                                                                                             'lookahead' => 0,
                                                                                             'argcode' => undef,
                                                                                             'implicit' => undef,
                                                                                             'line' => 12,
                                                                                             'matchrule' => 0
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'line' => 12,
                                                                                             'lookahead' => 0,
                                                                                             'code' => '{$return = [@{$item{BLOCK}}]}',
                                                                                             'hashname' => '__ACTION1__'
                                                                                           }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                  ]
                                                                     }, 'Parse::RecDescent::_Runtime::Production' ),
                                                              bless( {
                                                                       'dircount' => 0,
                                                                       'number' => 1,
                                                                       'patcount' => 0,
                                                                       'uncommit' => undef,
                                                                       'error' => undef,
                                                                       'line' => undef,
                                                                       'actcount' => 1,
                                                                       'strcount' => 0,
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'lookahead' => 0,
                                                                                             'argcode' => undef,
                                                                                             'implicit' => undef,
                                                                                             'subrule' => 'BLOCK',
                                                                                             'matchrule' => 0,
                                                                                             'line' => 13
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'line' => 13,
                                                                                             'code' => '{$return = [@{$item{BLOCK}}]}',
                                                                                             'hashname' => '__ACTION1__',
                                                                                             'lookahead' => 0
                                                                                           }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                  ]
                                                                     }, 'Parse::RecDescent::_Runtime::Production' ),
                                                              bless( {
                                                                       'uncommit' => undef,
                                                                       'patcount' => 0,
                                                                       'dircount' => 0,
                                                                       'number' => 2,
                                                                       'strcount' => 0,
                                                                       'actcount' => 1,
                                                                       'line' => undef,
                                                                       'error' => undef,
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'line' => 14,
                                                                                             'matchrule' => 0,
                                                                                             'subrule' => 'COMMENT',
                                                                                             'implicit' => undef,
                                                                                             'argcode' => undef,
                                                                                             'lookahead' => 0
                                                                                           }, 'Parse::RecDescent::_Runtime::Subrule' ),
                                                                                    bless( {
                                                                                             'lookahead' => 0,
                                                                                             'code' => '{$return = []}',
                                                                                             'hashname' => '__ACTION1__',
                                                                                             'line' => 14
                                                                                           }, 'Parse::RecDescent::_Runtime::Action' )
                                                                                  ]
                                                                     }, 'Parse::RecDescent::_Runtime::Production' )
                                                            ],
                                                 'name' => 'LINE',
                                                 'opcount' => 0,
                                                 'changed' => 0,
                                                 'vars' => '',
                                                 'calls' => [
                                                              'BLOCK',
                                                              'COMMENT'
                                                            ],
                                                 'impcount' => 0,
                                                 'line' => 12
                                               }, 'Parse::RecDescent::_Runtime::Rule' ),
                              'EMPTY' => bless( {
                                                  'line' => 95,
                                                  'calls' => [],
                                                  'impcount' => 0,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'opcount' => 0,
                                                  'name' => 'EMPTY',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'description' => '//',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => '',
                                                                                              'line' => 95,
                                                                                              'lookahead' => 0,
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'rdelim' => '/',
                                                                                              'mod' => ''
                                                                                            }, 'Parse::RecDescent::_Runtime::Token' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'patcount' => 1,
                                                                        'actcount' => 0,
                                                                        'line' => undef,
                                                                        'error' => undef,
                                                                        'strcount' => 0
                                                                      }, 'Parse::RecDescent::_Runtime::Production' )
                                                             ]
                                                }, 'Parse::RecDescent::_Runtime::Rule' )
                            }
               }, 'Parse::RecDescent::_Runtime' );
}