package LaTeXML::MathGrammar;
use Parse::RecDescent;
{ my $ERRORS;


package Parse::RecDescent::LaTeXML::MathGrammar;
use strict;
use vars qw($skip $AUTOLOAD  $MaxAbsDepth $MaxAbsDepth $MaxAbsDepth $forbidVertBar $forbidLRAngle $forbidEvalAt $MaxAbsDepth );
@Parse::RecDescent::LaTeXML::MathGrammar::ISA = ();
$skip = '\s*';
 BEGIN{ use LaTeXML::MathParser qw(:constructors); 
#### $::RD_TRACE=1;
};


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

    ${"AUTOLOAD"} =~ s/^Parse::RecDescent::LaTeXML::MathGrammar/Parse::RecDescent/;
    goto &{${"AUTOLOAD"}};
}
}

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

    Parse::RecDescent::_trace(q{Trying rule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{POSTSUPERSCRIPT},
                  $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::Expectation(q{/POSTSUPERSCRIPT:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/POSTSUPERSCRIPT:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{POSTSUPERSCRIPT},
                      $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(?:POSTSUPERSCRIPT:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{POSTSUPERSCRIPT},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{POSTSUPERSCRIPT},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{POSTSUPERSCRIPT},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{POSTSUPERSCRIPT},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [evalAtOp]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{evalAtOp},
                  $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::Expectation(q{VERTBAR, or /CLOSE:\\|:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [VERTBAR]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{evalAtOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{evalAtOp});
        %item = (__RULE__ => q{evalAtOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{evalAtOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{evalAtOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/CLOSE:\\|:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{evalAtOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{evalAtOp});
        %item = (__RULE__ => q{evalAtOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/CLOSE:\\|:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{evalAtOp},
                      $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(?:CLOSE:\|:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/CLOSE:\\|:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{evalAtOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{evalAtOp},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{evalAtOp},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{evalAtOp},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{evalAtOp},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [anyOpIsolator]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{anyOpIsolator},
                  $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::Expectation(q{/^\\Z/, or PUNCT, or CLOSE});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{anyOpIsolator},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{anyOpIsolator},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{anyOpIsolator});
        %item = (__RULE__ => q{anyOpIsolator});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{anyOpIsolator},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{anyOpIsolator},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{anyOpIsolator},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::CLOSE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [CLOSE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{anyOpIsolator},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [CLOSE]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{anyOpIsolator},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{anyOpIsolator},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{anyOpIsolator},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{anyOpIsolator},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [relop]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{relop},
                  $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::Expectation(q{RELOP, or ARROW});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/RELOP:(less|greater)-than:\\d+/ <commit> <reject>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{relop});
        %item = (__RULE__ => q{relop});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying terminal: [/RELOP:(less|greater)-than:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/RELOP:(less|greater)-than:\\d+/})->at($text);
        

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

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

        

        Parse::RecDescent::_trace(q{Trying directive: [<commit>]},
                    Parse::RecDescent::_tracefirst($text),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE; 
        $_tok = do { $commit = 1 };
        if (defined($_tok))
        {
            Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
                        . $_tok . q{])},
                        Parse::RecDescent::_tracefirst($text))
                            if defined $::RD_TRACE;
        }
        else
        {
            Parse::RecDescent::_trace(q{<<Didn't match directive>>},
                        Parse::RecDescent::_tracefirst($text))
                            if defined $::RD_TRACE;
        }
        
        last unless defined $_tok;
        push @item, $item{__DIRECTIVE1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <reject>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [/RELOP:(less|greater)-than:\\d+/ <commit> <reject>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [RELOP addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{relop});
        %item = (__RULE__ => q{relop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [RELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::RELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [RELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [RELOP]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ARROW addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{relop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{relop});
        %item = (__RULE__ => q{relop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ARROW]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARROW($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARROW]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARROW]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{relop},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{relop},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{relop},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{relop},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [factorOpen]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{factorOpen},
                  $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::Expectation(q{AddOp, or preScripted, or Factor, or Expression, or balancedClose, or AnyOp});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AddOp balancedClose addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpen});
        %item = (__RULE__ => q{factorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AddOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AddOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AddOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AddOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($arg[0],$item[1],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [AddOp balancedClose addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted balancedClose addScripts Factor]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpen});
        %item = (__RULE__ => q{factorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['bigop'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($arg[0],$item[1],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Factor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted balancedClose addScripts Factor]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Factor preScripted balancedClose addScripts Factor]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpen});
        %item = (__RULE__ => q{factorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{preScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['bigop'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($arg[0],
                        Apply(InvisibleTimes(),$item[1],$item[2]),$item[3])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Factor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [Factor preScripted balancedClose addScripts Factor]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Expression factorOpenExpr]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpen});
        %item = (__RULE__ => q{factorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [factorOpenExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{factorOpenExpr})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::factorOpenExpr($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [factorOpenExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [factorOpenExpr]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [balancedClose addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpen});
        %item = (__RULE__ => q{factorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp factorOpenExpr]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpen});
        %item = (__RULE__ => q{factorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [factorOpenExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{factorOpenExpr})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::factorOpenExpr($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [factorOpenExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [factorOpenExpr]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{factorOpen},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{factorOpen},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{factorOpen},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{factorOpen},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [moreTrigBareargs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreTrigBareargs},
                  $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::Expectation(q{/^\\Z/, or MulOp, or aTrigBarearg});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreTrigBareargs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp aTrigBarearg moreTrigBareargs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreTrigBareargs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreTrigBareargs});
        %item = (__RULE__ => q{moreTrigBareargs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTrigBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTrigBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [aTrigBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTrigBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{aTrigBarearg})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aTrigBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aTrigBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTrigBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aTrigBarearg]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreTrigBareargs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTrigBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreTrigBareargs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreTrigBareargs($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary($item[1],$arg[0],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreTrigBareargs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTrigBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreTrigBareargs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [aTrigBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTrigBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aTrigBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aTrigBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTrigBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aTrigBarearg]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreTrigBareargs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTrigBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreTrigBareargs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreTrigBareargs($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary(InvisibleTimes(),$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreTrigBareargs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTrigBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreTrigBareargs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreTrigBareargs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreTrigBareargs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreTrigBareargs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreTrigBareargs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [nestOperators]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{nestOperators},
                  $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::Expectation(q{/^\\Z/, or OPERATOR, or FUNCTION, or OPFUNCTION, or TRIGFUNCTION, or OPEN});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{nestOperators},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPERATOR addScripts nestOperators]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{nestOperators});
        %item = (__RULE__ => q{nestOperators});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPERATOR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPERATOR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPERATOR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPERATOR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [nestOperators]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{nestOperators})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::nestOperators($thisparser,$text,$repeating,$_noactions,sub { return [@arg,$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [nestOperators]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [nestOperators]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FUNCTION addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{nestOperators});
        %item = (__RULE__ => q{nestOperators});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FUNCTION]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FUNCTION($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FUNCTION]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FUNCTION]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPFUNCTION addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{nestOperators});
        %item = (__RULE__ => q{nestOperators});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPFUNCTION]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPFUNCTION($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPFUNCTION]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPFUNCTION]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [TRIGFUNCTION addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{nestOperators});
        %item = (__RULE__ => q{nestOperators});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [TRIGFUNCTION]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::TRIGFUNCTION($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [TRIGFUNCTION]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [TRIGFUNCTION]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN Expression balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{nestOperators});
        %item = (__RULE__ => q{nestOperators});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{nestOperators},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{nestOperators},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [OPEN Expression balancedClose]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{nestOperators},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[6];
        $text = $_[1];
        my $_savetext;
        @item = (q{nestOperators});
        %item = (__RULE__ => q{nestOperators});
        my $repcount = 0;


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{nestOperators},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{nestOperators},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{nestOperators},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{nestOperators},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Formulae]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Formulae},
                  $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::Expectation(q{Formula});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Formula moreFormulae]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Formulae},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Formulae});
        %item = (__RULE__ => q{Formulae});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Formula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Formulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Formulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formula]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreFormulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Formulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFormulae})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFormulae($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFormulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Formulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFormulae]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Formulae},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Formulae},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Formulae},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Formulae},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{METARELOP},
                  $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::Expectation(q{/METARELOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/METARELOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{METARELOP},
                      $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(?:METARELOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{METARELOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{METARELOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{METARELOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{METARELOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [maybeEvalAt]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{maybeEvalAt},
                  $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::Expectation(q{POSTSUBSCRIPT, or POSTSUPERSCRIPT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUBSCRIPT moreEvalAt]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeEvalAt});
        %item = (__RULE__ => q{maybeEvalAt});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreEvalAt]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreEvalAt})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreEvalAt($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$arg[1],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreEvalAt]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreEvalAt]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUPERSCRIPT POSTSUBSCRIPT moreFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeEvalAt});
        %item = (__RULE__ => q{maybeEvalAt});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{POSTSUBSCRIPT})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFactors($thisparser,$text,$repeating,$_noactions,sub { return [NewEvalAt($arg[0],$arg[1],$item[2],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFactors]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUPERSCRIPT POSTSUBSCRIPT moreFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{maybeEvalAt},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{maybeEvalAt},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{maybeEvalAt},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{maybeEvalAt},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [suchThatOp]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{suchThatOp},
                  $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::Expectation(q{MIDDLE, or VERTBAR, or /METARELOP:colon:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MIDDLE]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{suchThatOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{suchThatOp});
        %item = (__RULE__ => q{suchThatOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MIDDLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{suchThatOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MIDDLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MIDDLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{suchThatOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MIDDLE]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [VERTBAR]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{suchThatOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{suchThatOp});
        %item = (__RULE__ => q{suchThatOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{suchThatOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{suchThatOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/METARELOP:colon:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{suchThatOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{suchThatOp});
        %item = (__RULE__ => q{suchThatOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/METARELOP:colon:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{suchThatOp},
                      $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(?:METARELOP:colon:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/METARELOP:colon:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{suchThatOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{suchThatOp},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{suchThatOp},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{suchThatOp},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{suchThatOp},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [MODIFIEROP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{MODIFIEROP},
                  $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::Expectation(q{/MODIFIEROP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/MODIFIEROP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MODIFIEROP},
                      $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(?:MODIFIEROP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{MODIFIEROP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{MODIFIEROP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{MODIFIEROP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{MODIFIEROP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Superscript]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Superscript},
                  $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::Expectation(q{aSuperscript});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

     local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH;


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Superscript});
        %item = (__RULE__ => q{Superscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [aSuperscript PUNCT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{Superscript});
        %item = (__RULE__ => q{Superscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [aSuperscript]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Superscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aSuperscript($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aSuperscript]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Superscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aSuperscript]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Superscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{PUNCT})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_Superscript, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Superscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_2_of_rule_Superscript]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{_alternation_1_of_production_2_of_rule_Superscript(s?)}} = $_tok;
        push @item, $_tok;
        


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Superscript},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Superscript},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Superscript},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Superscript},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [maybeBra]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{maybeBra},
                  $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::Expectation(q{ketExpression});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ketExpression maybeBraket]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeBra},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeBra});
        %item = (__RULE__ => q{maybeBra});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ketExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBra},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ketExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ketExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBra},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ketExpression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [maybeBraket]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBra},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeBraket})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeBraket($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$arg[1],$arg[2],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeBraket]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBra},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeBraket]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeBra},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeBra});
        %item = (__RULE__ => q{maybeBra});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBra},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [InterpretDelimited(New('bra'),
                     Annotate($arg[0],role=>'OPEN'),$arg[1],Annotate($arg[2],role=>'CLOSE'))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBra},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{maybeBra},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{maybeBra},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{maybeBra},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{maybeBra},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [scriptFactorOpen]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{scriptFactorOpen},
                  $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::Expectation(q{Formula, or factorOpen});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Formula suchThatOp Formulae balancedClose addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{scriptFactorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{scriptFactorOpen});
        %item = (__RULE__ => q{scriptFactorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Formula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{scriptFactorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{scriptFactorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formula]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [suchThatOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{scriptFactorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{suchThatOp})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::suchThatOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [suchThatOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{scriptFactorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [suchThatOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Formulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{scriptFactorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Formulae})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{scriptFactorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formulae]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{scriptFactorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{scriptFactorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{scriptFactorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [InterpretDelimited(New('conditional-set'),
                                    $arg[0], $item[1],$item[2], $item[3],$item[4])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{scriptFactorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [Formula suchThatOp Formulae balancedClose addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{scriptFactorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [factorOpen]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{scriptFactorOpen},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{scriptFactorOpen});
        %item = (__RULE__ => q{scriptFactorOpen});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [factorOpen]},
                  Parse::RecDescent::_tracefirst($text),
                  q{scriptFactorOpen},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::factorOpen($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [factorOpen]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{scriptFactorOpen},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [factorOpen]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{scriptFactorOpen},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{scriptFactorOpen},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{scriptFactorOpen},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{scriptFactorOpen},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [moreTerms]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreTerms},
                  $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::Expectation(q{/^\\Z/, or AddOp});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreTerms},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AddOp moreTerms2]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreTerms},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreTerms});
        %item = (__RULE__ => q{moreTerms});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AddOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTerms},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AddOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AddOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTerms},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AddOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreTerms2]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTerms},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreTerms2})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreTerms2($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$arg[1],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreTerms2]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTerms},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreTerms2]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreTerms},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreTerms},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreTerms},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreTerms},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [UNKNOWN]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{UNKNOWN},
                  $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::Expectation(q{/UNKNOWN:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/UNKNOWN:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{UNKNOWN},
                      $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(?:UNKNOWN:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{UNKNOWN},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{UNKNOWN},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{UNKNOWN},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{UNKNOWN},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [ATOM]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ATOM},
                  $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::Expectation(q{/ATOM:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/ATOM:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{ATOM},
                      $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(?:ATOM:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ATOM},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ATOM},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ATOM},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ATOM},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_factorOpenExpr]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                  $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::Expectation(q{PUNCT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_1_of_rule_factorOpenExpr});
        %item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_factorOpenExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_1_of_rule_factorOpenExpr},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [INTOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{INTOP},
                  $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::Expectation(q{/INTOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/INTOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{INTOP},
                      $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(?:INTOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{INTOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{INTOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{INTOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{INTOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Argument]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Argument},
                  $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::Expectation(q{Expression});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Expression extendArgument]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Argument},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Argument});
        %item = (__RULE__ => q{Argument});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Argument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Argument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [extendArgument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Argument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{extendArgument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::extendArgument($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [extendArgument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Argument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [extendArgument]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Argument},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Argument},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Argument},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Argument},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [modifierFormula]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{modifierFormula},
                  $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::Expectation(q{relop});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relop Expression moreRHS]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{modifierFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{modifierFormula});
        %item = (__RULE__ => q{modifierFormula});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{modifierFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{modifierFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{modifierFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{modifierFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreRHS]},
                  Parse::RecDescent::_tracefirst($text),
                  q{modifierFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreRHS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreRHS($thisparser,$text,$repeating,$_noactions,sub { return [Absent(),$item[1],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreRHS]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{modifierFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreRHS]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [relop Expression moreRHS]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{modifierFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{modifierFormula},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{modifierFormula},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{modifierFormula},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{modifierFormula},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [BIGOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{BIGOP},
                  $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::Expectation(q{/BIGOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/BIGOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{BIGOP},
                      $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(?:BIGOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{BIGOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{BIGOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{BIGOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{BIGOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [modifierFormulae]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{modifierFormulae},
                  $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::Expectation(q{modifierFormula});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [modifierFormula moreFormulae]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{modifierFormulae},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{modifierFormulae});
        %item = (__RULE__ => q{modifierFormulae});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [modifierFormula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{modifierFormulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::modifierFormula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [modifierFormula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{modifierFormulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [modifierFormula]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreFormulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{modifierFormulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFormulae})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFormulae($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFormulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{modifierFormulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFormulae]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{modifierFormulae},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{modifierFormulae},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{modifierFormulae},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{modifierFormulae},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [extendArgument]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{extendArgument},
                  $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::Expectation(q{/^\\Z/, or relopExpr, or METARELOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{extendArgument},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relopExpr extendArgument]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{extendArgument},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{extendArgument});
        %item = (__RULE__ => q{extendArgument});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [relopExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendArgument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::relopExpr, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [relopExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendArgument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [relopExpr]<< (}
                    . @$_tok . q{ times)},

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


        Parse::RecDescent::_trace(q{Trying subrule: [extendArgument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendArgument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{extendArgument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::extendArgument($thisparser,$text,$repeating,$_noactions,sub { return [NewFormula($arg[0],map(@$_,@{$item[1]}))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [extendArgument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendArgument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [extendArgument]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [METARELOP Formula extendArgument]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{extendArgument},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{extendArgument});
        %item = (__RULE__ => q{extendArgument});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendArgument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::METARELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [METARELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendArgument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [METARELOP]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Formula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendArgument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Formula})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendArgument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formula]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [extendArgument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendArgument},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{extendArgument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::extendArgument($thisparser,$text,$repeating,$_noactions,sub { return [Apply($item[1],$arg[0],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [extendArgument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendArgument},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [extendArgument]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{extendArgument},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{extendArgument},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{extendArgument},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{extendArgument},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [trigBarearg]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{trigBarearg},
                  $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::Expectation(q{aTrigBarearg});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [aTrigBarearg moreTrigBareargs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{trigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{trigBarearg});
        %item = (__RULE__ => q{trigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [aTrigBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{trigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aTrigBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aTrigBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{trigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aTrigBarearg]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreTrigBareargs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{trigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreTrigBareargs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreTrigBareargs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreTrigBareargs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{trigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreTrigBareargs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{trigBarearg},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{trigBarearg},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{trigBarearg},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{trigBarearg},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [moreBareargs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreBareargs},
                  $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::Expectation(q{/^\\Z/, or MulOp, or aBarearg});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreBareargs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp aBarearg moreBareargs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreBareargs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreBareargs});
        %item = (__RULE__ => q{moreBareargs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [aBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{aBarearg})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aBarearg]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreBareargs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreBareargs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreBareargs($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary($item[1],$arg[0],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreBareargs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreBareargs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [aBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aBarearg]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreBareargs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreBareargs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreBareargs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreBareargs($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary(InvisibleTimes(),$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreBareargs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreBareargs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreBareargs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreBareargs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreBareargs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreBareargs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreBareargs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_2_of_rule_moreFormulae]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_2_of_rule_moreFormulae},
                  $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::Expectation(q{endPunct});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [endPunct Formula]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_2_of_rule_moreFormulae},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_2_of_rule_moreFormulae});
        %item = (__RULE__ => q{_alternation_1_of_production_2_of_rule_moreFormulae});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [endPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_moreFormulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::endPunct($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [endPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_moreFormulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [endPunct]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Formula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_moreFormulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Formula})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_moreFormulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formula]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_2_of_rule_moreFormulae},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_2_of_rule_moreFormulae},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_2_of_rule_moreFormulae},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_2_of_rule_moreFormulae},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Expression]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Expression},
                  $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::Expectation(q{SignedTerm, or AnyOp});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [SignedTerm moreTerms addExpressionModifier]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Expression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Expression});
        %item = (__RULE__ => q{Expression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [SignedTerm]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SignedTerm($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SignedTerm]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SignedTerm]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreTerms]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreTerms})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreTerms($thisparser,$text,$repeating,$_noactions,sub { return [[],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreTerms]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreTerms]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addExpressionModifier]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addExpressionModifier})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addExpressionModifier($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addExpressionModifier]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addExpressionModifier]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [SignedTerm moreTerms addExpressionModifier]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Expression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp anyOpIsolator]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Expression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{Expression});
        %item = (__RULE__ => q{Expression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [anyOpIsolator]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{anyOpIsolator})->at($text);
        $_savetext = $text;unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::anyOpIsolator($thisparser,$text,$repeating,1,sub { \@arg },undef)))
        {
            $text = $_savetext;
            Parse::RecDescent::_trace(q{<<...Didn't match(reject) subrule: [anyOpIsolator]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>...Matched(keep) subrule: [anyOpIsolator]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Expression},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Expression},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Expression},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Expression},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [argPunct]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{argPunct},
                  $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::Expectation(q{PUNCT, or MIDDLE, or VERTBAR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{argPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{argPunct});
        %item = (__RULE__ => q{argPunct});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{argPunct},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{argPunct},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MIDDLE]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{argPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{argPunct});
        %item = (__RULE__ => q{argPunct});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MIDDLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{argPunct},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MIDDLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MIDDLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{argPunct},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MIDDLE]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{argPunct},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{argPunct},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{argPunct},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{argPunct},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{argPunct},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{argPunct},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [FLOATSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{FLOATSUBSCRIPT},
                  $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::Expectation(q{/FLOATSUBSCRIPT:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/FLOATSUBSCRIPT:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{FLOATSUBSCRIPT},
                      $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(?:FLOATSUBSCRIPT:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{FLOATSUBSCRIPT},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{FLOATSUBSCRIPT},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{FLOATSUBSCRIPT},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{FLOATSUBSCRIPT},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [forbidArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{forbidArgs},
                  $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::Expectation(q{Argument, or Term});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Argument argPunct balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{forbidArgs});
        %item = (__RULE__ => q{forbidArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Argument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Argument($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Argument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Argument]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying repeated subrule: [argPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{argPunct})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_1_of_rule_forbidArgs, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [argPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_1_of_rule_forbidArgs]<< (}
                    . @$_tok . q{ times)},

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


        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [Argument argPunct balancedClose]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Term balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{forbidArgs});
        %item = (__RULE__ => q{forbidArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Term]},
                  Parse::RecDescent::_tracefirst($text),
                  q{forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Term($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Term]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Term]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{forbidArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{forbidArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{forbidArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{forbidArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [LBRACE]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{LBRACE},
                  $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::Expectation(q{/OPEN:\\\{:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/OPEN:\\\{:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{LBRACE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{LBRACE});
        %item = (__RULE__ => q{LBRACE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/OPEN:\\\{:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{LBRACE},
                      $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(?:OPEN:\{:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{LBRACE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{LBRACE},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{LBRACE},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{LBRACE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_8_of_rule_AnythingAny]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_8_of_rule_AnythingAny},
                  $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::Expectation(q{PUNCT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT AnyOp]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_8_of_rule_AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_8_of_rule_AnythingAny});
        %item = (__RULE__ => q{_alternation_1_of_production_8_of_rule_AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_8_of_rule_AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::PUNCT, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_8_of_rule_AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [PUNCT]<< (}
                    . @$_tok . q{ times)},

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


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_8_of_rule_AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{AnyOp})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_8_of_rule_AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_8_of_rule_AnythingAny},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_8_of_rule_AnythingAny},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_8_of_rule_AnythingAny},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_8_of_rule_AnythingAny},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [RANGLE]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{RANGLE},
                  $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::Expectation(q{/RELOP:greater-than:\\d+/, or /CLOSE:rangle:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/RELOP:greater-than:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{RANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{RANGLE});
        %item = (__RULE__ => q{RANGLE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/RELOP:greater-than:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{RANGLE},
                      $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(?:RELOP:greater-than:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/RELOP:greater-than:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{RANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/CLOSE:rangle:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{RANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{RANGLE});
        %item = (__RULE__ => q{RANGLE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/CLOSE:rangle:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{RANGLE},
                      $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(?:CLOSE:rangle:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/CLOSE:rangle:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{RANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{RANGLE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{RANGLE},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{RANGLE},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{RANGLE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [SCRIPTOPEN]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{SCRIPTOPEN},
                  $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::Expectation(q{/OPEN:\\\{:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/OPEN:\\\{:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{SCRIPTOPEN},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SCRIPTOPEN});
        %item = (__RULE__ => q{SCRIPTOPEN});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/OPEN:\\\{:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{SCRIPTOPEN},
                      $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(?:OPEN:\{:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{SCRIPTOPEN},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{SCRIPTOPEN},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SCRIPTOPEN},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{SCRIPTOPEN},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Term]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Term},
                  $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::Expectation(q{Factor});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Factor moreFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Term},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Term});
        %item = (__RULE__ => q{Term});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Term},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Term},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Term},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFactors($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Term},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFactors]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Term},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Term},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Term},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Term},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Factor]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Factor},
                  $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::Expectation(q{OPEN, or LBRACE, or ARRAY, or preScripted, or NUMBER, or SCRIPTOPEN, or OPERATOR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN ARRAY CLOSE addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [ARRAY]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{ARRAY})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARRAY($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARRAY]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARRAY]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{CLOSE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::CLOSE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [CLOSE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [CLOSE]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($item[1],$item[2],$item[3])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [OPEN ARRAY CLOSE addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [LBRACE ARRAY]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [LBRACE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::LBRACE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [LBRACE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [LBRACE]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [ARRAY]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{ARRAY})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARRAY($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARRAY]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARRAY]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ARRAY RBRACE]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ARRAY]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARRAY($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARRAY]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARRAY]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [RBRACE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{RBRACE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::RBRACE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [RBRACE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [RBRACE]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['FUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addOpFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['OPFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addOpFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpFunArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addTrigFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['TRIGFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addTrigFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addTrigFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addTrigFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addTrigFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addTrigFunArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted maybeArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[6];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['ATOM_OR_ID'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [maybeArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted doubtArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[7];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['UNKNOWN'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [doubtArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{doubtArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::doubtArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [doubtArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [doubtArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [NUMBER addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[8];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [NUMBER]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [SCRIPTOPEN scriptFactorOpen]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[9];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [SCRIPTOPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SCRIPTOPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SCRIPTOPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SCRIPTOPEN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [scriptFactorOpen]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{scriptFactorOpen})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::scriptFactorOpen($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [scriptFactorOpen]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [scriptFactorOpen]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN factorOpen]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[10];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [factorOpen]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{factorOpen})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::factorOpen($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [factorOpen]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [factorOpen]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addIntOpArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[11];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['INTOP'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addIntOpArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addIntOpArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addIntOpArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addIntOpArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addIntOpArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addOpArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[12];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['bigop'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addOpArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [SINGLEVERTBAR SINGLEVERTBAR absExpression SINGLEVERTBAR SINGLEVERTBAR addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[13];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [SINGLEVERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SINGLEVERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SINGLEVERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SINGLEVERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SINGLEVERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [SINGLEVERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SINGLEVERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SINGLEVERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SINGLEVERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SINGLEVERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [absExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{absExpression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::absExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [absExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [absExpression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [SINGLEVERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SINGLEVERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SINGLEVERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SINGLEVERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SINGLEVERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [SINGLEVERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{SINGLEVERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SINGLEVERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SINGLEVERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SINGLEVERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence(CatSymbols($item[2],$item[3],undef,'||',role=>'OPEN'),
                $item[4],
                CatSymbols($item[5],$item[6],undef,'||',role=>'CLOSE'))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [SINGLEVERTBAR SINGLEVERTBAR absExpression SINGLEVERTBAR SINGLEVERTBAR addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [VERTBAR absExpression VERTBAR addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[14];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{VERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [absExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{absExpression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::absExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [absExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [absExpression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{VERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($item[2],$item[3],$item[4])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [VERTBAR absExpression VERTBAR addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MIDBAR ketExpression RANGLE addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[15];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [MIDBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{MIDBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MIDBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MIDBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MIDBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [ketExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{ketExpression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ketExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ketExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ketExpression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [RANGLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{RANGLE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::RANGLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [RANGLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [RANGLE]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [InterpretDelimited(New('ket'),
                    Annotate($item[2],role=>'OPEN'),$item[3],Annotate($item[4],role=>'CLOSE'))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [MIDBAR ketExpression RANGLE addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [LANGLE ketExpression MIDBAR maybeBra]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[16];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [LANGLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{LANGLE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::LANGLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [LANGLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [LANGLE]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [ketExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{ketExpression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ketExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ketExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ketExpression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [MIDBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{MIDBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MIDBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MIDBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MIDBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [maybeBra]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeBra})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeBra($thisparser,$text,$repeating,$_noactions,sub { return [$item[2],$item[3],$item[4]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeBra]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeBra]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [LANGLE ketExpression MIDBAR maybeBra]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [LANGLE absExpression RANGLE addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[17];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [LANGLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{LANGLE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::LANGLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [LANGLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [LANGLE]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [absExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{absExpression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::absExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [absExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [absExpression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [RANGLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{RANGLE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::RANGLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [RANGLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [RANGLE]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence(Annotate($item[2],role=>'OPEN'),
                          $item[3],
                          Annotate($item[4],role=>'CLOSE'))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [LANGLE absExpression RANGLE addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPERATOR addScripts nestOperators addOpFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[18];
        $text = $_[1];
        my $_savetext;
        @item = (q{Factor});
        %item = (__RULE__ => q{Factor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPERATOR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPERATOR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPERATOR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPERATOR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [nestOperators]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{nestOperators})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::nestOperators($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [nestOperators]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [nestOperators]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addOpFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Factor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[3]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Factor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpFunArgs]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [OPERATOR addScripts nestOperators addOpFunArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Factor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Factor},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Factor},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Factor},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Factor},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [TRIGFUNCTION]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{TRIGFUNCTION},
                  $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::Expectation(q{/TRIGFUNCTION:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/TRIGFUNCTION:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{TRIGFUNCTION},
                      $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(?:TRIGFUNCTION:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{TRIGFUNCTION},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{TRIGFUNCTION},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{TRIGFUNCTION},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{TRIGFUNCTION},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [extendFormula]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{extendFormula},
                  $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::Expectation(q{/^\\Z/, or punctExpr, or relop});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{extendFormula},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [punctExpr maybeRHS]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{extendFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{extendFormula});
        %item = (__RULE__ => q{extendFormula});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [punctExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::punctExpr, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [punctExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [punctExpr]<< (}
                    . @$_tok . q{ times)},

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


        Parse::RecDescent::_trace(q{Trying subrule: [maybeRHS]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeRHS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeRHS($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],map(@$_,@{$item[1]})] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeRHS]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeRHS]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relop Expression moreRHS]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{extendFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{extendFormula});
        %item = (__RULE__ => q{extendFormula});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreRHS]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreRHS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreRHS($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[1],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreRHS]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreRHS]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [relop Expression moreRHS]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{extendFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{extendFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{extendFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{extendFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/^\\Z/})->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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{extendFormula},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{extendFormula},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{extendFormula},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{extendFormula},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [moreOpArgFactors]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreOpArgFactors},
                  $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::Expectation(q{/^\\Z/, or MulOp, or Factor});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreOpArgFactors},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp Factor moreOpArgFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreOpArgFactors});
        %item = (__RULE__ => q{moreOpArgFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Factor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreOpArgFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreOpArgFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreOpArgFactors($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary($item[1],$arg[0],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreOpArgFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreOpArgFactors]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreOpArgFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreOpArgFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreOpArgFactors($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary(InvisibleTimes(),$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreOpArgFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreOpArgFactors]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreOpArgFactors},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreOpArgFactors},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreOpArgFactors},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreOpArgFactors},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [addArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addArgs},
                  $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::Expectation(q{/^\\Z/, or addEasyArgs, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [addEasyArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addArgs});
        %item = (__RULE__ => q{addArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [addEasyArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addEasyArgs($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addEasyArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addEasyArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP barearg]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addArgs});
        %item = (__RULE__ => q{addArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [APPLYOP]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [barearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{barearg})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::barearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [barearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [barearg]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [maybeRHS]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{maybeRHS},
                  $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::Expectation(q{/^\\Z/, or relopExpr});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{maybeRHS},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relopExpr]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeRHS});
        %item = (__RULE__ => q{maybeRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [relopExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::relopExpr, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [relopExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [relopExpr]<< (}
                    . @$_tok . q{ times)},

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


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

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{maybeRHS},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{maybeRHS},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{maybeRHS},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{maybeRHS},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [MULOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{MULOP},
                  $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::Expectation(q{/MULOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/MULOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MULOP},
                      $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(?:MULOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{MULOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{MULOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{MULOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{MULOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [POSTFIX]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{POSTFIX},
                  $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::Expectation(q{/POSTFIX:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/POSTFIX:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{POSTFIX},
                      $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(?:POSTFIX:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{POSTFIX},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{POSTFIX},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{POSTFIX},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{POSTFIX},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [aSuperscript]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{aSuperscript},
                  $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::Expectation(q{supops, or Formulae, or AnyOp});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [supops]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aSuperscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{aSuperscript});
        %item = (__RULE__ => q{aSuperscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [supops]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSuperscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::supops($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [supops]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSuperscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [supops]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Formulae]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aSuperscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{aSuperscript});
        %item = (__RULE__ => q{aSuperscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Formulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSuperscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSuperscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formulae]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aSuperscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{aSuperscript});
        %item = (__RULE__ => q{aSuperscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSuperscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSuperscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSuperscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSuperscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSuperscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSuperscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{aSuperscript},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{aSuperscript},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{aSuperscript},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{aSuperscript},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [SUMOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{SUMOP},
                  $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::Expectation(q{/SUMOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/SUMOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{SUMOP},
                      $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(?:SUMOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{SUMOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{SUMOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SUMOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{SUMOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [COMPOSEOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{COMPOSEOP},
                  $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::Expectation(q{/COMPOSEOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/COMPOSEOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{COMPOSEOP},
                      $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(?:COMPOSEOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{COMPOSEOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{COMPOSEOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{COMPOSEOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{COMPOSEOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [LANGLE]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{LANGLE},
                  $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::Expectation(q{/RELOP:less-than:\\d+/, or /OPEN:langle:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/RELOP:less-than:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{LANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{LANGLE});
        %item = (__RULE__ => q{LANGLE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/RELOP:less-than:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{LANGLE},
                      $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(?:RELOP:less-than:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/RELOP:less-than:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{LANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/OPEN:langle:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{LANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{LANGLE});
        %item = (__RULE__ => q{LANGLE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/OPEN:langle:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{LANGLE},
                      $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(?:OPEN:langle:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/OPEN:langle:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{LANGLE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{LANGLE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{LANGLE},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{LANGLE},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{LANGLE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [NUMBER]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{NUMBER},
                  $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::Expectation(q{/NUMBER:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/NUMBER:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{NUMBER},
                      $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(?:NUMBER:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{NUMBER},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{NUMBER},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{NUMBER},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{NUMBER},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [punctExpr]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{punctExpr},
                  $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::Expectation(q{PUNCT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{punctExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{punctExpr});
        %item = (__RULE__ => q{punctExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{punctExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{punctExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{punctExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{punctExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{punctExpr},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{punctExpr},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{punctExpr},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{punctExpr},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [OPEN]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{OPEN},
                  $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::Expectation(q{/OPEN:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/OPEN:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{OPEN},
                      $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(?:OPEN:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{OPEN},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{OPEN},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{OPEN},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{OPEN},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [ADDOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ADDOP},
                  $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::Expectation(q{/ADDOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/ADDOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{ADDOP},
                      $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(?:ADDOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ADDOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ADDOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ADDOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ADDOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [aTrigBarearg]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{aTrigBarearg},
                  $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::Expectation(q{preScripted, or NUMBER, or VERTBAR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{aTrigBarearg});
        %item = (__RULE__ => q{aTrigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['FUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addOpFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{aTrigBarearg});
        %item = (__RULE__ => q{aTrigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['OPFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addOpFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpFunArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted maybeArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{aTrigBarearg});
        %item = (__RULE__ => q{aTrigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['ATOM_OR_ID'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [maybeArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted doubtArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{aTrigBarearg});
        %item = (__RULE__ => q{aTrigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['UNKNOWN'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [doubtArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{doubtArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::doubtArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [doubtArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [doubtArgs]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [NUMBER addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{aTrigBarearg});
        %item = (__RULE__ => q{aTrigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [NUMBER]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [VERTBAR Expression VERTBAR addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{aTrigBarearg});
        %item = (__RULE__ => q{aTrigBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{VERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aTrigBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($item[1],$item[2],$item[3])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aTrigBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{>>Matched production: [VERTBAR Expression VERTBAR addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aTrigBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{aTrigBarearg},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{aTrigBarearg},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{aTrigBarearg},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{aTrigBarearg},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [OPFUNCTION]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{OPFUNCTION},
                  $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::Expectation(q{/OPFUNCTION:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/OPFUNCTION:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{OPFUNCTION},
                      $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(?:OPFUNCTION:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{OPFUNCTION},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{OPFUNCTION},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{OPFUNCTION},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{OPFUNCTION},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [OPERATOR]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{OPERATOR},
                  $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::Expectation(q{/OPERATOR:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/OPERATOR:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{OPERATOR},
                      $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(?:OPERATOR:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{OPERATOR},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{OPERATOR},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{OPERATOR},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{OPERATOR},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [addIntOpArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addIntOpArgs},
                  $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::Expectation(q{/^\\Z/, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addIntOpArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP IntFactor moreIntOpArgFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addIntOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addIntOpArgs});
        %item = (__RULE__ => q{addIntOpArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addIntOpArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addIntOpArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [APPLYOP]<< (}
                    . @$_tok . q{ times)},

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


        Parse::RecDescent::_trace(q{Trying subrule: [IntFactor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addIntOpArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{IntFactor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::IntFactor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [IntFactor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addIntOpArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [IntFactor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreIntOpArgFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addIntOpArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreIntOpArgFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreIntOpArgFactors($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreIntOpArgFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addIntOpArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreIntOpArgFactors]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP IntFactor moreIntOpArgFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addIntOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addIntOpArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addIntOpArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addIntOpArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addIntOpArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [FUNCTION]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{FUNCTION},
                  $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::Expectation(q{/FUNCTION:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/FUNCTION:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{FUNCTION},
                      $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(?:FUNCTION:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{FUNCTION},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{FUNCTION},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{FUNCTION},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{FUNCTION},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{POSTSUBSCRIPT},
                  $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::Expectation(q{/POSTSUBSCRIPT:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/POSTSUBSCRIPT:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{POSTSUBSCRIPT},
                      $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(?:POSTSUBSCRIPT:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{POSTSUBSCRIPT},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{POSTSUBSCRIPT},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{POSTSUBSCRIPT},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{POSTSUBSCRIPT},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [SINGLEVERTBAR]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{SINGLEVERTBAR},
                  $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::Expectation(q{/VERTBAR:\\|:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/VERTBAR:\\|:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{SINGLEVERTBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SINGLEVERTBAR});
        %item = (__RULE__ => q{SINGLEVERTBAR});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/VERTBAR:\\|:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{SINGLEVERTBAR},
                      $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(?:VERTBAR:\|:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/VERTBAR:\\|:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{SINGLEVERTBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{SINGLEVERTBAR},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{SINGLEVERTBAR},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SINGLEVERTBAR},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{SINGLEVERTBAR},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [Anything]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Anything},
                  $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::Expectation(q{AnythingAny});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

     local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH;


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Anything},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Anything});
        %item = (__RULE__ => q{Anything});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{Anything},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Anything},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [AnythingAny]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Anything},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnythingAny($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnythingAny]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Anything},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnythingAny]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{Anything},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/^\\Z/})->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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Anything},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Anything},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Anything},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Anything},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [BINOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{BINOP},
                  $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::Expectation(q{/BINOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/BINOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{BINOP},
                      $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(?:BINOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{BINOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{BINOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{BINOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{BINOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [moreFormulae]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreFormulae},
                  $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::Expectation(q{/^\\Z/, or endPunct, or metarelopFormula});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreFormulae},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [endPunct]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreFormulae},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreFormulae});
        %item = (__RULE__ => q{moreFormulae});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [endPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFormulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_moreFormulae, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [endPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFormulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_2_of_rule_moreFormulae]<< (}
                    . @$_tok . q{ times)},

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


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

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying repeated subrule: [metarelopFormula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFormulae},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::metarelopFormula, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [metarelopFormula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFormulae},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [metarelopFormula]<< (}
                    . @$_tok . q{ times)},

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


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

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

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



        $_matched = 1;
        last;
    }


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


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreFormulae},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreFormulae},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreFormulae},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreFormulae},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [IntFactor]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{IntFactor},
                  $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::Expectation(q{diffd, or Factor});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [diffd ATOM_OR_ID addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{IntFactor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{IntFactor});
        %item = (__RULE__ => q{IntFactor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [diffd]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::diffd($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [diffd]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [diffd]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [ATOM_OR_ID]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{ATOM_OR_ID})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ATOM_OR_ID($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ATOM_OR_ID]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ATOM_OR_ID]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [diffd ATOM_OR_ID addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{IntFactor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [diffd UNKNOWN addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{IntFactor},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{IntFactor});
        %item = (__RULE__ => q{IntFactor});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [diffd]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::diffd($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [diffd]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [diffd]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [UNKNOWN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{UNKNOWN})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::UNKNOWN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [UNKNOWN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [UNKNOWN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [diffd UNKNOWN addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{IntFactor},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{IntFactor},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{IntFactor},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{IntFactor},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{IntFactor},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{IntFactor},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{IntFactor},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [MIDBAR]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{MIDBAR},
                  $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::Expectation(q{/VERTBAR:\\S*:\\d+/, or /MIDDLE:\\|:\\d+/, or /MIDDLE:parallel-to:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/VERTBAR:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MIDBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{MIDBAR});
        %item = (__RULE__ => q{MIDBAR});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/VERTBAR:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MIDBAR},
                      $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(?:VERTBAR:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/MIDDLE:\\|:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MIDBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{MIDBAR});
        %item = (__RULE__ => q{MIDBAR});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/MIDDLE:\\|:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MIDBAR},
                      $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(?:MIDDLE:\|:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/MIDDLE:\\|:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{MIDBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/MIDDLE:parallel-to:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MIDBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{MIDBAR});
        %item = (__RULE__ => q{MIDBAR});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/MIDDLE:parallel-to:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MIDBAR},
                      $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(?:MIDDLE:parallel-to:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [/MIDDLE:parallel-to:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{MIDBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{MIDBAR},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{MIDBAR},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{MIDBAR},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{MIDBAR},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreFactors},
                  $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::Expectation(q{/^\\Z/, or MulOp, or COMPOSEOP, or Factor});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

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


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreFactors},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp Factor moreFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreFactors});
        %item = (__RULE__ => q{moreFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Factor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFactors($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary($item[1],$arg[0],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFactors]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [COMPOSEOP makeComposition]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreFactors});
        %item = (__RULE__ => q{moreFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [COMPOSEOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::COMPOSEOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [COMPOSEOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [COMPOSEOP]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [makeComposition]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{makeComposition})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::makeComposition($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [makeComposition]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [makeComposition]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [evalAtOp maybeEvalAt]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreFactors});
        %item = (__RULE__ => q{moreFactors});
        my $repcount = 0;


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

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

        Parse::RecDescent::_trace(q{Trying subrule: [evalAtOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{evalAtOp})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::evalAtOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [evalAtOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [evalAtOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [maybeEvalAt]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeEvalAt})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeEvalAt($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeEvalAt]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeEvalAt]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFactors($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary(InvisibleTimes(),$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFactors]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreFactors});
        %item = (__RULE__ => q{moreFactors});
        my $repcount = 0;


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

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

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



        $_matched = 1;
        last;
    }


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

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreFactors},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreFactors},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreFactors},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreFactors},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

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

    Parse::RecDescent::_trace(q{Trying rule: [AnythingAny]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{AnythingAny},
                  $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::Expectation(q{Formulae, or OPEN, or modifierFormulae, or MODIFIER, or MODIFIEROP, or METARELOP, or AnyOp, or FLOATSUPERSCRIPT, or FLOATSUBSCRIPT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Formulae]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Formulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formulae]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN Formulae CLOSE]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Formulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Formulae})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formulae]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{CLOSE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::CLOSE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [CLOSE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [CLOSE]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [OPEN Formulae CLOSE]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [modifierFormulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::modifierFormulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [modifierFormulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [modifierFormulae]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN modifierFormula CLOSE]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [modifierFormula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{modifierFormula})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::modifierFormula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [modifierFormula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [modifierFormula]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{CLOSE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::CLOSE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [CLOSE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [CLOSE]<< (return value: [}
                    . $_tok . q{]},

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

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

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

        Parse::RecDescent::_trace(q{>>Matched production: [OPEN modifierFormula CLOSE]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


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


        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIER]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIER($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIER]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIER]<< (return value: [}
                    . $_tok . q{]},

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MODIFIEROP Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIEROP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIEROP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIEROP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIEROP]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [METARELOP Formula]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[6];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::METARELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [METARELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [METARELOP]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [Formula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Formula})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formula]<< (return value: [}
                    . $_tok . q{]},

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

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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp PUNCT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[7];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{PUNCT})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_8_of_rule_AnythingAny, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_8_of_rule_AnythingAny]<< (}
                    . @$_tok . q{ times)},

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


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

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

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



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUPERSCRIPT POSTSUBSCRIPT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[8];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{POSTSUBSCRIPT})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

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

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript(NewScript(Absent(),$item[1]),$item[2]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUPERSCRIPT POSTSUBSCRIPT]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUBSCRIPT POSTSUPERSCRIPT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[9];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{POSTSUPERSCRIPT})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript(NewScript(Absent(),$item[1]),$item[2]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUBSCRIPT POSTSUPERSCRIPT]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUPERSCRIPT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[10];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript(Absent(),$item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUPERSCRIPT]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUBSCRIPT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[11];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript(Absent(),$item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUBSCRIPT]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[12];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnythingAny});
        %item = (__RULE__ => q{AnythingAny});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AnyOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnythingAny},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnythingAny},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($item[1],Absent(),$item[2]);};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [AnyOp Expression]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnythingAny},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{AnythingAny},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{AnythingAny},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{AnythingAny},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{AnythingAny},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_1_of_rule_requireArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_1_of_rule_requireArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_requireArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_1_of_rule_requireArgs},
                  $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::Expectation(q{argPunct});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [argPunct Argument]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_1_of_rule_requireArgs});
        %item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_requireArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [argPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_1_of_rule_requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::argPunct($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [argPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_1_of_rule_requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [argPunct]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{argPunct}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Argument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_1_of_rule_requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Argument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Argument($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Argument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_1_of_rule_requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Argument]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Argument}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do {[$item[1],$item[2]];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [argPunct Argument]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_1_of_rule_requireArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_1_of_rule_requireArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::LIMITOP
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"LIMITOP"};

    Parse::RecDescent::_trace(q{Trying rule: [LIMITOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{LIMITOP},
                  $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::Expectation(q{/LIMITOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/LIMITOP:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{LIMITOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{LIMITOP});
        %item = (__RULE__ => q{LIMITOP});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/LIMITOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{LIMITOP},
                      $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(?:LIMITOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{LIMITOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/LIMITOP:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{LIMITOP},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{LIMITOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{LIMITOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{LIMITOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{LIMITOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::makeComposition
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"makeComposition"};

    Parse::RecDescent::_trace(q{Trying rule: [makeComposition]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{makeComposition},
                  $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::Expectation(q{preScripted, or Factor});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{makeComposition});
        %item = (__RULE__ => q{makeComposition});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['FUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addArgs($thisparser,$text,$repeating,$_noactions,sub { return [Apply($arg[1],$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $item[2]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted addArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addOpFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{makeComposition});
        %item = (__RULE__ => q{makeComposition});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['OPFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [Apply($arg[1],$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpFunArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpFunArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $item[2]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted addOpFunArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addTrigFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{makeComposition});
        %item = (__RULE__ => q{makeComposition});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['TRIGFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addTrigFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addTrigFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addTrigFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [Apply($arg[1],$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addTrigFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addTrigFunArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addTrigFunArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $item[2]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted addTrigFunArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Factor addArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{makeComposition});
        %item = (__RULE__ => q{makeComposition});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Factor}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{makeComposition},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addArgs($thisparser,$text,$repeating,$_noactions,sub { return [Apply($arg[1],$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{makeComposition},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $item[2]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [Factor addArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{makeComposition},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{makeComposition},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{makeComposition},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{makeComposition},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{makeComposition},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::SUPOP
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SUPOP"};

    Parse::RecDescent::_trace(q{Trying rule: [SUPOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{SUPOP},
                  $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::Expectation(q{/SUPOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/SUPOP:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{SUPOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SUPOP});
        %item = (__RULE__ => q{SUPOP});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/SUPOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{SUPOP},
                      $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(?:SUPOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{SUPOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/SUPOP:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{SUPOP},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{SUPOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{SUPOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SUPOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{SUPOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::endPunct
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"endPunct"};

    Parse::RecDescent::_trace(q{Trying rule: [endPunct]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{endPunct},
                  $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::Expectation(q{PUNCT, or PERIOD});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{endPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{endPunct});
        %item = (__RULE__ => q{endPunct});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{endPunct},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{endPunct},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{endPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{endPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PERIOD]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{endPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{endPunct});
        %item = (__RULE__ => q{endPunct});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PERIOD]},
                  Parse::RecDescent::_tracefirst($text),
                  q{endPunct},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PERIOD($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PERIOD]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{endPunct},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PERIOD]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{endPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PERIOD}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [PERIOD]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{endPunct},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{endPunct},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{endPunct},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{endPunct},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{endPunct},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::absExpression
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"absExpression"};

    Parse::RecDescent::_trace(q{Trying rule: [absExpression]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{absExpression},
                  $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::Expectation(q{});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

     local $forbidEvalAt = 1;
 local $MaxAbsDepth = $MaxAbsDepth-1;


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $forbidEvalAt = 1>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{absExpression});
        %item = (__RULE__ => q{absExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $forbidEvalAt = 1>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $forbidEvalAt = 1>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $MaxAbsDepth = $MaxAbsDepth-1>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{absExpression});
        %item = (__RULE__ => q{absExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $MaxAbsDepth = $MaxAbsDepth-1>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $MaxAbsDepth = $MaxAbsDepth-1>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{absExpression});
        %item = (__RULE__ => q{absExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { ($MaxAbsDepth >= 0 ? 1 : (SawNotation('AbsFail')&& undef)); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{absExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{absExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [Expression]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{absExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{absExpression},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{absExpression},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{absExpression},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{absExpression},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::maybeColRHS
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"maybeColRHS"};

    Parse::RecDescent::_trace(q{Trying rule: [maybeColRHS]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{maybeColRHS},
                  $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::Expectation(q{/^\\Z/, or relop, or PUNCT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeColRHS});
        %item = (__RULE__ => q{maybeColRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewFormula($arg[0],$arg[1],NewList(@arg[2..$#arg])); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relop Expression moreRHS]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeColRHS});
        %item = (__RULE__ => q{maybeColRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeColRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeColRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{relop}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeColRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeColRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreRHS]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeColRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreRHS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreRHS($thisparser,$text,$repeating,$_noactions,sub { return [$arg[$#arg],$item[1],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreRHS]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeColRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreRHS]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreRHS}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewFormulae(NewFormula($arg[0],$arg[1],
                          NewList(@arg[2..$#arg-2])),$arg[$#arg-1],$item[3]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [relop Expression moreRHS]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT Expression maybeColRHS]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeColRHS});
        %item = (__RULE__ => q{maybeColRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeColRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeColRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeColRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeColRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [maybeColRHS]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeColRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeColRHS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeColRHS($thisparser,$text,$repeating,$_noactions,sub { return [@arg,$item[1],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeColRHS]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeColRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeColRHS]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{maybeColRHS}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT Expression maybeColRHS]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeColRHS});
        %item = (__RULE__ => q{maybeColRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewFormula($arg[0],$arg[1],NewList(@arg[2..$#arg])); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeColRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{maybeColRHS},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{maybeColRHS},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{maybeColRHS},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{maybeColRHS},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::Expressions
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"Expressions"};

    Parse::RecDescent::_trace(q{Trying rule: [Expressions]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Expressions},
                  $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::Expectation(q{Expression});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Expression punctExpr]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Expressions},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Expressions});
        %item = (__RULE__ => q{Expressions});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expressions},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expressions},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{Expressions},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying repeated subrule: [punctExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Expressions},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{punctExpr})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::punctExpr, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [punctExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Expressions},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [punctExpr]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{Expressions},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{punctExpr(s?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{Expressions},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewList($item[1],map(@$_,@{$item[2]})); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [Expression punctExpr]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Expressions},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Expressions},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Expressions},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Expressions},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Expressions},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_addEasyArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_2_of_rule_addEasyArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_2_of_rule_addEasyArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                  $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::Expectation(q{argPunct});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [argPunct Argument]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_2_of_rule_addEasyArgs});
        %item = (__RULE__ => q{_alternation_1_of_production_2_of_rule_addEasyArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [argPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::argPunct($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [argPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [argPunct]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{argPunct}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Argument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Argument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Argument($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Argument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Argument]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Argument}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do {[$item[1],$item[2]];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [argPunct Argument]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_2_of_rule_addEasyArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::supops
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"supops"};

    Parse::RecDescent::_trace(q{Trying rule: [supops]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{supops},
                  $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::Expectation(q{SUPOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [SUPOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{supops},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{supops});
        %item = (__RULE__ => q{supops});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [SUPOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{supops},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::SUPOP, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [SUPOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{supops},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [SUPOP]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{supops},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SUPOP(s)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{supops},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { New(undef,
                                                      join('',map($_->textContent,@{$item[1]})),
                                                       name=>'prime'.scalar(@{$item[1]})); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [SUPOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{supops},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{supops},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{supops},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{supops},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{supops},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_Subscript
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_2_of_rule_Subscript"};

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_2_of_rule_Subscript]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_2_of_rule_Subscript},
                  $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::Expectation(q{PUNCT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT aSubscript]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_2_of_rule_Subscript});
        %item = (__RULE__ => q{_alternation_1_of_production_2_of_rule_Subscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_Subscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::PUNCT, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_Subscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [PUNCT]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [aSubscript]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_Subscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{aSubscript})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aSubscript($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aSubscript]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_Subscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aSubscript]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{aSubscript}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do {[$item[1]->[0] || InvisibleComma(),$item[2]]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT aSubscript]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_2_of_rule_Subscript},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_2_of_rule_Subscript},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"VERTBAR"};

    Parse::RecDescent::_trace(q{Trying rule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{VERTBAR},
                  $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::Expectation(q{/VERTBAR:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/VERTBAR:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{VERTBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{VERTBAR});
        %item = (__RULE__ => q{VERTBAR});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/VERTBAR:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{VERTBAR},
                      $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(?:VERTBAR:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{VERTBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/VERTBAR:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{VERTBAR},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{VERTBAR},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{VERTBAR},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{VERTBAR},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{VERTBAR},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::RBRACE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"RBRACE"};

    Parse::RecDescent::_trace(q{Trying rule: [RBRACE]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{RBRACE},
                  $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::Expectation(q{/CLOSE:\\\}:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/CLOSE:\\\}:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{RBRACE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{RBRACE});
        %item = (__RULE__ => q{RBRACE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/CLOSE:\\\}:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{RBRACE},
                      $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(?:CLOSE:\}:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{RBRACE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/CLOSE:\\\}:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{RBRACE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{RBRACE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{RBRACE},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{RBRACE},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{RBRACE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"APPLYOP"};

    Parse::RecDescent::_trace(q{Trying rule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{APPLYOP},
                  $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::Expectation(q{/APPLYOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/APPLYOP:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{APPLYOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{APPLYOP});
        %item = (__RULE__ => q{APPLYOP});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/APPLYOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{APPLYOP},
                      $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(?:APPLYOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{APPLYOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/APPLYOP:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{APPLYOP},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{APPLYOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{APPLYOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{APPLYOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{APPLYOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::bigop
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"bigop"};

    Parse::RecDescent::_trace(q{Trying rule: [bigop]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{bigop},
                  $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::Expectation(q{BIGOP, or SUMOP, or INTOP, or LIMITOP, or DIFFOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [BIGOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{bigop});
        %item = (__RULE__ => q{bigop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [BIGOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{bigop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::BIGOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [BIGOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{bigop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [BIGOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BIGOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [BIGOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [SUMOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{bigop});
        %item = (__RULE__ => q{bigop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [SUMOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{bigop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::SUMOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [SUMOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{bigop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [SUMOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{SUMOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [SUMOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [INTOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{bigop});
        %item = (__RULE__ => q{bigop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [INTOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{bigop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::INTOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [INTOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{bigop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [INTOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{INTOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [INTOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [LIMITOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{bigop});
        %item = (__RULE__ => q{bigop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [LIMITOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{bigop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::LIMITOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [LIMITOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{bigop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [LIMITOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{LIMITOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [LIMITOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [DIFFOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{bigop});
        %item = (__RULE__ => q{bigop});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [DIFFOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{bigop},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::DIFFOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [DIFFOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{bigop},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [DIFFOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{DIFFOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [DIFFOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{bigop},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{bigop},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{bigop},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{bigop},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{bigop},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::moreEvalAt
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"moreEvalAt"};

    Parse::RecDescent::_trace(q{Trying rule: [moreEvalAt]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreEvalAt},
                  $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::Expectation(q{POSTSUPERSCRIPT, or moreFactors});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUPERSCRIPT moreFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreEvalAt});
        %item = (__RULE__ => q{moreEvalAt});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFactors($thisparser,$text,$repeating,$_noactions,sub { return [NewEvalAt($arg[0],$arg[1],$arg[2],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFactors]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreFactors}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUPERSCRIPT moreFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [moreFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreEvalAt});
        %item = (__RULE__ => q{moreEvalAt});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [moreFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreEvalAt},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreFactors($thisparser,$text,$repeating,$_noactions,sub { return [NewEvalAt($arg[0],$arg[1],$arg[2],undef)] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreEvalAt},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreFactors]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreFactors}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [moreFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreEvalAt},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreEvalAt},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreEvalAt},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreEvalAt},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreEvalAt},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::balancedClose
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"balancedClose"};

    Parse::RecDescent::_trace(q{Trying rule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{balancedClose},
                  $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::Expectation(q{CLOSE});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [CLOSE]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{balancedClose},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{balancedClose});
        %item = (__RULE__ => q{balancedClose});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{balancedClose},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::CLOSE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [CLOSE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{balancedClose},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [CLOSE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{balancedClose},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{CLOSE}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{balancedClose},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { (isMatchingClose($arg[0],$item[1]) ? 1 : undef) };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{balancedClose},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $item[1]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION2__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [CLOSE]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{balancedClose},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{balancedClose},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{balancedClose},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{balancedClose},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{balancedClose},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::CLOSE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"CLOSE"};

    Parse::RecDescent::_trace(q{Trying rule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{CLOSE},
                  $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::Expectation(q{/CLOSE:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/CLOSE:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{CLOSE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{CLOSE});
        %item = (__RULE__ => q{CLOSE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/CLOSE:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{CLOSE},
                      $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(?:CLOSE:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{CLOSE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/CLOSE:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{CLOSE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{CLOSE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{CLOSE},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{CLOSE},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{CLOSE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::maybeBraket
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"maybeBraket"};

    Parse::RecDescent::_trace(q{Trying rule: [maybeBraket]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{maybeBraket},
                  $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::Expectation(q{RANGLE, or MIDBAR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [RANGLE addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeBraket});
        %item = (__RULE__ => q{maybeBraket});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [RANGLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBraket},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::RANGLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [RANGLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBraket},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [RANGLE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{RANGLE}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { SawNotation('QM'); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBraket},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [InterpretDelimited(New('inner-product', undef,role=>'MIDDLE'),
                                   Annotate($arg[0],role=>'OPEN'),$arg[1],
                                   Annotate($arg[2],role=>'MIDDLE'),
                                   $arg[3],Annotate($item[1],role=>'CLOSE'))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBraket},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [RANGLE addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MIDBAR ketExpression RANGLE addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeBraket});
        %item = (__RULE__ => q{maybeBraket});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MIDBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBraket},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MIDBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MIDBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBraket},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MIDBAR]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MIDBAR}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [ketExpression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBraket},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{ketExpression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ketExpression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ketExpression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBraket},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ketExpression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ketExpression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [RANGLE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBraket},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{RANGLE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::RANGLE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [RANGLE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBraket},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [RANGLE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{RANGLE}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { SawNotation('QM'); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeBraket},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [InterpretDelimited(New('quantum-operator-product',undef), # Is this a good representation?
                            Annotate($arg[0],role=>'OPEN'),$arg[1],
                                     Annotate($arg[2],role=>'CLOSE'),
                            $arg[3],
                            Annotate($item[1],role=>'OPEN'),$item[2],
                                    Annotate($item[3],role=>'CLOSE'))] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeBraket},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MIDBAR ketExpression RANGLE addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeBraket},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{maybeBraket},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{maybeBraket},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{maybeBraket},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{maybeBraket},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::doubtArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"doubtArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [doubtArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{doubtArgs},
                  $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::Expectation(q{/^\\Z/, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{doubtArgs});
        %item = (__RULE__ => q{doubtArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP requireArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{doubtArgs});
        %item = (__RULE__ => q{doubtArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{doubtArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{doubtArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [APPLYOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{APPLYOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [requireArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{doubtArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{requireArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::requireArgs($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [requireArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{doubtArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [requireArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{requireArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP requireArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN forbidArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{doubtArgs});
        %item = (__RULE__ => q{doubtArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { IsNotationAllowed('MaybeFunctions'); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{doubtArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{OPEN})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{doubtArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPEN}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [forbidArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{doubtArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{forbidArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::forbidArgs($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [forbidArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{doubtArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [forbidArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{forbidArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [OPEN forbidArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{doubtArgs});
        %item = (__RULE__ => q{doubtArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{doubtArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{doubtArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{doubtArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{doubtArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{doubtArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::aBarearg
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"aBarearg"};

    Parse::RecDescent::_trace(q{Trying rule: [aBarearg]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{aBarearg},
                  $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::Expectation(q{preScripted, or NUMBER, or VERTBAR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['FUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted addArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addOpFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['OPFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpFunArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpFunArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted addOpFunArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted addTrigFunArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['TRIGFUNCTION'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addTrigFunArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addTrigFunArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addTrigFunArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addTrigFunArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addTrigFunArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addTrigFunArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted addTrigFunArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted maybeArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['ATOM_OR_ID'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [maybeArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{maybeArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted maybeArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted doubtArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['UNKNOWN'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [doubtArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{doubtArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::doubtArgs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [doubtArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [doubtArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{doubtArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted doubtArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [NUMBER addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [NUMBER]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::NUMBER($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [NUMBER]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [NUMBER]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{NUMBER}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [NUMBER addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [VERTBAR Expression VERTBAR addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[6];
        $text = $_[1];
        my $_savetext;
        @item = (q{aBarearg});
        %item = (__RULE__ => q{aBarearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{VERTBAR}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [VERTBAR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{VERTBAR})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::VERTBAR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [VERTBAR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [VERTBAR]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{VERTBAR}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aBarearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($item[1],$item[2],$item[3])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aBarearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [VERTBAR Expression VERTBAR addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aBarearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{aBarearg},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{aBarearg},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{aBarearg},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{aBarearg},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::ketExpression
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"ketExpression"};

    Parse::RecDescent::_trace(q{Trying rule: [ketExpression]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ketExpression},
                  $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::Expectation(q{Formulae, or METARELOP, or ARROW, or AddOp, or MulOp, or MODIFIEROP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

     local $forbidVertBar = 1;
 local $forbidLRAngle = 1;


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $forbidVertBar = 1>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $forbidVertBar = 1>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $forbidVertBar = 1>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $forbidLRAngle = 1>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $forbidLRAngle = 1>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $forbidLRAngle = 1>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Formulae]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Formulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ketExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ketExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formulae]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Formulae}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [Formulae]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [METARELOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ketExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::METARELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [METARELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ketExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [METARELOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{METARELOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [METARELOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ARROW]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ARROW]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ketExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARROW($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARROW]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ketExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARROW]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ARROW}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [ARROW]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AddOp]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AddOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ketExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AddOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AddOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ketExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AddOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AddOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [AddOp]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[6];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ketExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ketExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MulOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MulOp]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MODIFIEROP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[7];
        $text = $_[1];
        my $_savetext;
        @item = (q{ketExpression});
        %item = (__RULE__ => q{ketExpression});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIEROP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ketExpression},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIEROP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIEROP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ketExpression},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIEROP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MODIFIEROP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MODIFIEROP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ketExpression},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ketExpression},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ketExpression},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ketExpression},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ketExpression},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::AnyOp
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"AnyOp"};

    Parse::RecDescent::_trace(q{Trying rule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{AnyOp},
                  $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::Expectation(q{relop, or METARELOP, or ARROW, or AddOp, or MulOp, or MODIFIEROP, or preScripted, or OPERATOR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relop]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{relop}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [relop]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [METARELOP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::METARELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [METARELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [METARELOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{METARELOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [METARELOP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ARROW]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ARROW]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARROW($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARROW]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARROW]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ARROW}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [ARROW]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AddOp]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AddOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AddOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AddOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AddOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AddOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [AddOp]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MulOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MulOp]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MODIFIEROP]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIEROP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIEROP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIEROP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIEROP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MODIFIEROP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MODIFIEROP]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [preScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[6];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [preScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::preScripted($thisparser,$text,$repeating,$_noactions,sub { return ['bigop'] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [preScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [preScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{preScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [preScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPERATOR addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[7];
        $text = $_[1];
        my $_savetext;
        @item = (q{AnyOp});
        %item = (__RULE__ => q{AnyOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPERATOR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPERATOR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPERATOR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPERATOR]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPERATOR}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AnyOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AnyOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [OPERATOR addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AnyOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{AnyOp},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{AnyOp},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{AnyOp},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{AnyOp},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addExpressionModifier
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addExpressionModifier"};

    Parse::RecDescent::_trace(q{Trying rule: [addExpressionModifier]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addExpressionModifier},
                  $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::Expectation(q{/^\\Z/, or PUNCT, or MODIFIER, or MODIFIEROP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addExpressionModifier});
        %item = (__RULE__ => q{addExpressionModifier});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT OPEN relop Expression balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addExpressionModifier});
        %item = (__RULE__ => q{addExpressionModifier});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::PUNCT, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [PUNCT]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{OPEN})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPEN}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{relop})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{relop}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{balancedClose}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply(New('annotated'),$arg[0],
                    Fence($item[2], Apply($item[3],Absent(),$item[4]),$item[5])); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT OPEN relop Expression balancedClose]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT OPEN MODIFIEROP Expression balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addExpressionModifier});
        %item = (__RULE__ => q{addExpressionModifier});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::PUNCT, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [PUNCT]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{OPEN})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPEN}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIEROP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{MODIFIEROP})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIEROP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIEROP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIEROP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MODIFIEROP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{balancedClose}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($item[3],$arg[0],$item[4]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT OPEN MODIFIEROP Expression balancedClose]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MODIFIER]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{addExpressionModifier});
        %item = (__RULE__ => q{addExpressionModifier});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIER]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIER($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIER]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIER]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MODIFIER}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply(New('annotated'),$arg[0],$item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [MODIFIER]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MODIFIEROP Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{addExpressionModifier});
        %item = (__RULE__ => q{addExpressionModifier});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MODIFIEROP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MODIFIEROP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MODIFIEROP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MODIFIEROP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MODIFIEROP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addExpressionModifier},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addExpressionModifier},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($item[1],$arg[0],$item[2]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [MODIFIEROP Expression]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[5];
        $text = $_[1];
        my $_savetext;
        @item = (q{addExpressionModifier});
        %item = (__RULE__ => q{addExpressionModifier});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addExpressionModifier},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addExpressionModifier},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addExpressionModifier},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addExpressionModifier},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addExpressionModifier},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::ARROW
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"ARROW"};

    Parse::RecDescent::_trace(q{Trying rule: [ARROW]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ARROW},
                  $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::Expectation(q{/ARROW:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/ARROW:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ARROW},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{ARROW});
        %item = (__RULE__ => q{ARROW});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/ARROW:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{ARROW},
                      $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(?:ARROW:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{ARROW},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/ARROW:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ARROW},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ARROW},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ARROW},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ARROW},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ARROW},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::MulOp
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"MulOp"};

    Parse::RecDescent::_trace(q{Trying rule: [MulOp]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{MulOp},
                  $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::Expectation(q{BINOP, or MULOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [BINOP addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{MulOp});
        %item = (__RULE__ => q{MulOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [BINOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{MulOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::BINOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [BINOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{MulOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [BINOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BINOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{MulOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{MulOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpDecoration}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [BINOP addOpDecoration]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MULOP addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{MulOp});
        %item = (__RULE__ => q{MulOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MULOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{MulOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MULOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MULOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{MulOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MULOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MULOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{MulOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{MulOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpDecoration}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MULOP addOpDecoration]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{MulOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{MulOp},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{MulOp},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{MulOp},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{MulOp},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::MODIFIER
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"MODIFIER"};

    Parse::RecDescent::_trace(q{Trying rule: [MODIFIER]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{MODIFIER},
                  $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::Expectation(q{/MODIFIER:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/MODIFIER:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MODIFIER},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{MODIFIER});
        %item = (__RULE__ => q{MODIFIER});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/MODIFIER:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MODIFIER},
                      $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(?:MODIFIER:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{MODIFIER},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/MODIFIER:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{MODIFIER},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{MODIFIER},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{MODIFIER},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{MODIFIER},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{MODIFIER},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::SignedTerm
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"SignedTerm"};

    Parse::RecDescent::_trace(q{Trying rule: [SignedTerm]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{SignedTerm},
                  $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::Expectation(q{AddOp, or Term});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AddOp Term]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{SignedTerm});
        %item = (__RULE__ => q{SignedTerm});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AddOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{SignedTerm},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AddOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AddOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{SignedTerm},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AddOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AddOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Term]},
                  Parse::RecDescent::_tracefirst($text),
                  q{SignedTerm},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Term})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Term($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Term]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{SignedTerm},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Term]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Term}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($item[1],$item[2]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [AddOp Term]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Term]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{SignedTerm});
        %item = (__RULE__ => q{SignedTerm});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Term]},
                  Parse::RecDescent::_tracefirst($text),
                  q{SignedTerm},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Term($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Term]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{SignedTerm},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Term]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Term}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [Term]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{SignedTerm},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{SignedTerm},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{SignedTerm},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{SignedTerm},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{SignedTerm},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::PUNCT
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PUNCT"};

    Parse::RecDescent::_trace(q{Trying rule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{PUNCT},
                  $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::Expectation(q{/PUNCT:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/PUNCT:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{PUNCT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PUNCT});
        %item = (__RULE__ => q{PUNCT});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/PUNCT:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{PUNCT},
                      $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(?:PUNCT:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{PUNCT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/PUNCT:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{PUNCT},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{PUNCT},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{PUNCT},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PUNCT},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{PUNCT},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addEasyArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addEasyArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [addEasyArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addEasyArgs},
                  $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::Expectation(q{COMPOSEOP, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [COMPOSEOP makeComposition]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addEasyArgs});
        %item = (__RULE__ => q{addEasyArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [COMPOSEOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::COMPOSEOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [COMPOSEOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [COMPOSEOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{COMPOSEOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [makeComposition]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{makeComposition})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::makeComposition($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0],$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [makeComposition]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [makeComposition]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{makeComposition}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [COMPOSEOP makeComposition]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP OPEN Argument argPunct balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addEasyArgs});
        %item = (__RULE__ => q{addEasyArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [APPLYOP]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{APPLYOP(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{OPEN})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPEN}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Argument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Argument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Argument($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Argument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Argument]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Argument}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying repeated subrule: [argPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{argPunct})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_addEasyArgs, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [argPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_2_of_rule_addEasyArgs]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{_alternation_1_of_production_2_of_rule_addEasyArgs(s?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addEasyArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addEasyArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{balancedClose}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { ApplyDelimited($arg[0],$item[2],$item[3],
                                   map(@$_,@{$item[4]}),$item[5]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP OPEN Argument argPunct balancedClose]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addEasyArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addEasyArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addEasyArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addEasyArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addEasyArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::requireArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"requireArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [requireArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{requireArgs},
                  $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::Expectation(q{OPEN, or barearg});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPEN Argument argPunct balancedClose]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{requireArgs});
        %item = (__RULE__ => q{requireArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPEN]},
                  Parse::RecDescent::_tracefirst($text),
                  q{requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPEN($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPEN]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPEN]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPEN}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Argument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Argument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Argument($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Argument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Argument]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Argument}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying repeated subrule: [argPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{argPunct})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_1_of_rule_requireArgs, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [argPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_1_of_rule_requireArgs]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{_alternation_1_of_production_1_of_rule_requireArgs(s?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{balancedClose}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { ApplyDelimited($arg[0],$item[1],$item[2],
                                   map(@$_,@{$item[3]}),$item[4]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [OPEN Argument argPunct balancedClose]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [barearg]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{requireArgs});
        %item = (__RULE__ => q{requireArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [barearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{requireArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::barearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [barearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{requireArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [barearg]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{barearg}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($arg[0],$item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [barearg]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{requireArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{requireArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{requireArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{requireArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{requireArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addScripts
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addScripts"};

    Parse::RecDescent::_trace(q{Trying rule: [addScripts]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addScripts},
                  $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::Expectation(q{/^\\Z/, or POSTSUPERSCRIPT, or POSTSUBSCRIPT, or POSTFIX});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addScripts});
        %item = (__RULE__ => q{addScripts});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUPERSCRIPT addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addScripts});
        %item = (__RULE__ => q{addScripts});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addScripts},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addScripts},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addScripts},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [NewScript($arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addScripts},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUPERSCRIPT addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUBSCRIPT addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addScripts});
        %item = (__RULE__ => q{addScripts});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addScripts},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addScripts},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addScripts},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [NewScript($arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addScripts},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUBSCRIPT addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTFIX addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{addScripts});
        %item = (__RULE__ => q{addScripts});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTFIX]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addScripts},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTFIX($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTFIX]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addScripts},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTFIX]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTFIX}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addScripts},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Apply($item[1],$arg[0])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addScripts},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [POSTFIX addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{addScripts});
        %item = (__RULE__ => q{addScripts});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addScripts},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addScripts},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addScripts},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addScripts},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addScripts},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::Formula
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"Formula"};

    Parse::RecDescent::_trace(q{Trying rule: [Formula]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Formula},
                  $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::Expectation(q{Expression});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Expression extendFormula]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Formula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Formula});
        %item = (__RULE__ => q{Formula});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Formula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Formula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{Formula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [extendFormula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Formula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{extendFormula})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::extendFormula($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [extendFormula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Formula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [extendFormula]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{Formula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{extendFormula}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [Expression extendFormula]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Formula},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Formula},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Formula},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Formula},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Formula},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addOpArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addOpArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [addOpArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addOpArgs},
                  $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::Expectation(q{/^\\Z/, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpArgs});
        %item = (__RULE__ => q{addOpArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP Factor moreOpArgFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpArgs});
        %item = (__RULE__ => q{addOpArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [APPLYOP]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{APPLYOP(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [Factor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Factor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Factor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Factor]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Factor}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreOpArgFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreOpArgFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreOpArgFactors($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreOpArgFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreOpArgFactors]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreOpArgFactors}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($arg[0],$item[3]);};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP Factor moreOpArgFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpArgs});
        %item = (__RULE__ => q{addOpArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addOpArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addOpArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addOpArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addOpArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::metarelopFormula
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"metarelopFormula"};

    Parse::RecDescent::_trace(q{Trying rule: [metarelopFormula]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{metarelopFormula},
                  $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::Expectation(q{METARELOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [METARELOP Formula]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{metarelopFormula});
        %item = (__RULE__ => q{metarelopFormula});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{metarelopFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::METARELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [METARELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{metarelopFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [METARELOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{METARELOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Formula]},
                  Parse::RecDescent::_tracefirst($text),
                  q{metarelopFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Formula})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formula($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formula]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{metarelopFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formula]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Formula}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { [$item[1],$item[2]]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [METARELOP Formula]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [METARELOP /^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{metarelopFormula});
        %item = (__RULE__ => q{metarelopFormula});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [METARELOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{metarelopFormula},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::METARELOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [METARELOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{metarelopFormula},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [METARELOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{METARELOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/^\\Z/})->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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { [$item[1], Absent()]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [METARELOP /^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{metarelopFormula},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{metarelopFormula},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{metarelopFormula},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{metarelopFormula},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{metarelopFormula},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::moreIntOpArgFactors
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"moreIntOpArgFactors"};

    Parse::RecDescent::_trace(q{Trying rule: [moreIntOpArgFactors]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreIntOpArgFactors},
                  $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::Expectation(q{/^\\Z/, or MulOp, or IntFactor});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreIntOpArgFactors});
        %item = (__RULE__ => q{moreIntOpArgFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [MulOp IntFactor moreIntOpArgFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreIntOpArgFactors});
        %item = (__RULE__ => q{moreIntOpArgFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [MulOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreIntOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::MulOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [MulOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreIntOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [MulOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{MulOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [IntFactor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreIntOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{IntFactor})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::IntFactor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [IntFactor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreIntOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [IntFactor]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{IntFactor}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreIntOpArgFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreIntOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreIntOpArgFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreIntOpArgFactors($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary($item[1],$arg[0],$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreIntOpArgFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreIntOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreIntOpArgFactors]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreIntOpArgFactors}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [MulOp IntFactor moreIntOpArgFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [IntFactor moreIntOpArgFactors]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreIntOpArgFactors});
        %item = (__RULE__ => q{moreIntOpArgFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [IntFactor]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreIntOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::IntFactor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [IntFactor]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreIntOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [IntFactor]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{IntFactor}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreIntOpArgFactors]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreIntOpArgFactors},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreIntOpArgFactors})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreIntOpArgFactors($thisparser,$text,$repeating,$_noactions,sub { return [ApplyNary(InvisibleTimes(),$arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreIntOpArgFactors]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreIntOpArgFactors},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreIntOpArgFactors]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreIntOpArgFactors}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [IntFactor moreIntOpArgFactors]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreIntOpArgFactors});
        %item = (__RULE__ => q{moreIntOpArgFactors});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreIntOpArgFactors},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreIntOpArgFactors},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreIntOpArgFactors},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreIntOpArgFactors},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreIntOpArgFactors},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::barearg
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"barearg"};

    Parse::RecDescent::_trace(q{Trying rule: [barearg]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{barearg},
                  $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::Expectation(q{aBarearg});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [aBarearg moreBareargs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{barearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{barearg});
        %item = (__RULE__ => q{barearg});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [aBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{barearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{barearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aBarearg]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{barearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{aBarearg}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreBareargs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{barearg},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreBareargs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreBareargs($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreBareargs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{barearg},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreBareargs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{barearg},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreBareargs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [aBarearg moreBareargs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{barearg},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{barearg},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{barearg},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{barearg},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{barearg},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::factorOpenExpr
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"factorOpenExpr"};

    Parse::RecDescent::_trace(q{Trying rule: [factorOpenExpr]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{factorOpenExpr},
                  $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::Expectation(q{PUNCT, or balancedClose});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT CLOSE addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpenExpr});
        %item = (__RULE__ => q{factorOpenExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_1_of_rule_factorOpenExpr, 1, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_1_of_rule_factorOpenExpr]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{_alternation_1_of_production_1_of_rule_factorOpenExpr(s)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [CLOSE]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{CLOSE})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::CLOSE($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [CLOSE]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [CLOSE]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{CLOSE}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($arg[0],$arg[1],map(@$_,@{$item[1]}),$item[2])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT CLOSE addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT AnyOp balancedClose addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpenExpr});
        %item = (__RULE__ => q{factorOpenExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{AnyOp})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AnyOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{balancedClose})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{balancedClose}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [InterpretDelimited(New('group'),
                                            $arg[0],$arg[1],$item[1],$item[2],$item[3])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT AnyOp balancedClose addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [balancedClose addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{factorOpenExpr});
        %item = (__RULE__ => q{factorOpenExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [balancedClose]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::balancedClose($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [balancedClose]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [balancedClose]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{balancedClose}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{factorOpenExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [Fence($arg[0],$arg[1],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{factorOpenExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [balancedClose addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{factorOpenExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{factorOpenExpr},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{factorOpenExpr},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{factorOpenExpr},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{factorOpenExpr},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::MIDDLE
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"MIDDLE"};

    Parse::RecDescent::_trace(q{Trying rule: [MIDDLE]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{MIDDLE},
                  $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::Expectation(q{/MIDDLE:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/MIDDLE:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{MIDDLE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{MIDDLE});
        %item = (__RULE__ => q{MIDDLE});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/MIDDLE:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{MIDDLE},
                      $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(?:MIDDLE:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{MIDDLE},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/MIDDLE:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{MIDDLE},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{MIDDLE},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{MIDDLE},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{MIDDLE},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{MIDDLE},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::Subscript
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"Subscript"};

    Parse::RecDescent::_trace(q{Trying rule: [Subscript]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Subscript},
                  $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::Expectation(q{aSubscript});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

     local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH;


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Subscript});
        %item = (__RULE__ => q{Subscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{>>Rejecting production<< (found <rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>)},
                     Parse::RecDescent::_tracefirst($text),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $return;
        

        $_tok = undef;
        
        last unless defined $_tok;

        Parse::RecDescent::_trace(q{>>Matched production: [<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [aSubscript PUNCT]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{Subscript});
        %item = (__RULE__ => q{Subscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [aSubscript]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Subscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aSubscript($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aSubscript]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Subscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aSubscript]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{aSubscript}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Subscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{PUNCT})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_Subscript, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Subscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [_alternation_1_of_production_2_of_rule_Subscript]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{_alternation_1_of_production_2_of_rule_Subscript(s?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewList($item[1],map(@$_,@{$item[2]})); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [aSubscript PUNCT]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Subscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Subscript},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Subscript},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Subscript},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Subscript},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::RELOP
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"RELOP"};

    Parse::RecDescent::_trace(q{Trying rule: [RELOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{RELOP},
                  $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::Expectation(q{/RELOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/RELOP:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{RELOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{RELOP});
        %item = (__RULE__ => q{RELOP});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/RELOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{RELOP},
                      $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(?:RELOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{RELOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/RELOP:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{RELOP},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{RELOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{RELOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{RELOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{RELOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_1_of_rule_forbidArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_1_of_rule_forbidArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_forbidArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_1_of_rule_forbidArgs},
                  $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::Expectation(q{argPunct});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [argPunct Argument]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_1_of_rule_forbidArgs});
        %item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_forbidArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [argPunct]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_1_of_rule_forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::argPunct($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [argPunct]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_1_of_rule_forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [argPunct]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{argPunct}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Argument]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_1_of_rule_forbidArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Argument})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Argument($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Argument]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_1_of_rule_forbidArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Argument]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Argument}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [argPunct Argument]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_1_of_rule_forbidArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_1_of_rule_forbidArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::ARRAY
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"ARRAY"};

    Parse::RecDescent::_trace(q{Trying rule: [ARRAY]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ARRAY},
                  $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::Expectation(q{/ARRAY:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/ARRAY:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ARRAY},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{ARRAY});
        %item = (__RULE__ => q{ARRAY});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/ARRAY:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{ARRAY},
                      $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(?:ARRAY:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{ARRAY},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/ARRAY:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ARRAY},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ARRAY},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ARRAY},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ARRAY},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ARRAY},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addTrigFunArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addTrigFunArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [addTrigFunArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addTrigFunArgs},
                  $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::Expectation(q{/^\\Z/, or addEasyArgs, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addTrigFunArgs});
        %item = (__RULE__ => q{addTrigFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [addEasyArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addTrigFunArgs});
        %item = (__RULE__ => q{addTrigFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [addEasyArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addTrigFunArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addEasyArgs($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addEasyArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addTrigFunArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addEasyArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addEasyArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [addEasyArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP trigBarearg]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addTrigFunArgs});
        %item = (__RULE__ => q{addTrigFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addTrigFunArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addTrigFunArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [APPLYOP]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{APPLYOP(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [trigBarearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addTrigFunArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{trigBarearg})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::trigBarearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [trigBarearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addTrigFunArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [trigBarearg]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{trigBarearg}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($arg[0],$item[2]);};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP trigBarearg]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{addTrigFunArgs});
        %item = (__RULE__ => q{addTrigFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addTrigFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addTrigFunArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addTrigFunArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addTrigFunArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addTrigFunArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addOpFunArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addOpFunArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [addOpFunArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addOpFunArgs},
                  $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::Expectation(q{/^\\Z/, or addEasyArgs, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpFunArgs});
        %item = (__RULE__ => q{addOpFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [addEasyArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpFunArgs});
        %item = (__RULE__ => q{addOpFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [addEasyArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpFunArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addEasyArgs($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addEasyArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpFunArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addEasyArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addEasyArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [addEasyArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP barearg]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpFunArgs});
        %item = (__RULE__ => q{addOpFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpFunArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpFunArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [APPLYOP]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{APPLYOP(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [barearg]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpFunArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{barearg})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::barearg($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [barearg]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpFunArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [barearg]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{barearg}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($arg[0],$item[2]);};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP barearg]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpFunArgs});
        %item = (__RULE__ => q{addOpFunArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpFunArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addOpFunArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addOpFunArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addOpFunArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addOpFunArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::_alternation_1_of_production_2_of_rule_Superscript
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_2_of_rule_Superscript"};

    Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_2_of_rule_Superscript]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{_alternation_1_of_production_2_of_rule_Superscript},
                  $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::Expectation(q{PUNCT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT aSuperscript]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{_alternation_1_of_production_2_of_rule_Superscript});
        %item = (__RULE__ => q{_alternation_1_of_production_2_of_rule_Superscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_Superscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::PUNCT, 0, 1, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_Superscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [PUNCT]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT(?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying subrule: [aSuperscript]},
                  Parse::RecDescent::_tracefirst($text),
                  q{_alternation_1_of_production_2_of_rule_Superscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{aSuperscript})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::aSuperscript($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [aSuperscript]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{_alternation_1_of_production_2_of_rule_Superscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [aSuperscript]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{aSuperscript}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do {[$item[1]->[0] || InvisibleComma(),$item[2]]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT aSuperscript]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{_alternation_1_of_production_2_of_rule_Superscript},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{_alternation_1_of_production_2_of_rule_Superscript},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::relopExpr
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"relopExpr"};

    Parse::RecDescent::_trace(q{Trying rule: [relopExpr]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{relopExpr},
                  $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::Expectation(q{relop});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relop Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{relopExpr});
        %item = (__RULE__ => q{relopExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relopExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relopExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{relop}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relopExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relopExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { [$item[1],$item[2]]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [relop Expression]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relop /^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{relopExpr});
        %item = (__RULE__ => q{relopExpr});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [relop]},
                  Parse::RecDescent::_tracefirst($text),
                  q{relopExpr},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::relop($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [relop]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{relopExpr},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [relop]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{relop}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/^\\Z/})->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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { [$item[1], Absent()]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [relop /^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{relopExpr},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{relopExpr},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{relopExpr},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{relopExpr},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{relopExpr},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::maybeArgs
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"maybeArgs"};

    Parse::RecDescent::_trace(q{Trying rule: [maybeArgs]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{maybeArgs},
                  $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::Expectation(q{/^\\Z/, or APPLYOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeArgs});
        %item = (__RULE__ => q{maybeArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [APPLYOP requireArgs]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeArgs});
        %item = (__RULE__ => q{maybeArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [APPLYOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::APPLYOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [APPLYOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [APPLYOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{APPLYOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [requireArgs]},
                  Parse::RecDescent::_tracefirst($text),
                  q{maybeArgs},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{requireArgs})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::requireArgs($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [requireArgs]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{maybeArgs},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [requireArgs]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{requireArgs}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [APPLYOP requireArgs]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{maybeArgs});
        %item = (__RULE__ => q{maybeArgs});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{maybeArgs},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{maybeArgs},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{maybeArgs},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{maybeArgs},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{maybeArgs},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::diffd
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"diffd"};

    Parse::RecDescent::_trace(q{Trying rule: [diffd]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{diffd},
                  $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::Expectation(q{/UNKNOWN:d:\\d+/, or /ID:d:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/UNKNOWN:d:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{diffd},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{diffd});
        %item = (__RULE__ => q{diffd});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/UNKNOWN:d:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{diffd},
                      $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(?:UNKNOWN:d:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{diffd},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/UNKNOWN:d:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{diffd},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/ID:d:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{diffd},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{diffd});
        %item = (__RULE__ => q{diffd});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/ID:d:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{diffd},
                      $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(?:ID:d:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{diffd},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/ID:d:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{diffd},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{diffd},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{diffd},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{diffd},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{diffd},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::Start
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"Start"};

    Parse::RecDescent::_trace(q{Trying rule: [Start]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{Start},
                  $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::Expectation(q{Anything});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Anything /^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{Start},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{Start});
        %item = (__RULE__ => q{Start});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Anything]},
                  Parse::RecDescent::_tracefirst($text),
                  q{Start},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Anything($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Anything]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{Start},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Anything]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{Start},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Anything}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{Start},
                      $tracelevel)
                        if defined $::RD_TRACE;
        undef $lastsep;
        $expectation->is(q{/^\\Z/})->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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{Start},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $item[1]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [Anything /^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{Start},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{Start},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{Start},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{Start},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{Start},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUPERSCRIPT
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"FLOATSUPERSCRIPT"};

    Parse::RecDescent::_trace(q{Trying rule: [FLOATSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{FLOATSUPERSCRIPT},
                  $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::Expectation(q{/FLOATSUPERSCRIPT:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/FLOATSUPERSCRIPT:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{FLOATSUPERSCRIPT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{FLOATSUPERSCRIPT});
        %item = (__RULE__ => q{FLOATSUPERSCRIPT});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/FLOATSUPERSCRIPT:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{FLOATSUPERSCRIPT},
                      $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(?:FLOATSUPERSCRIPT:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{FLOATSUPERSCRIPT},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/FLOATSUPERSCRIPT:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{FLOATSUPERSCRIPT},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{FLOATSUPERSCRIPT},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{FLOATSUPERSCRIPT},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{FLOATSUPERSCRIPT},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{FLOATSUPERSCRIPT},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::preScripted
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"preScripted"};

    Parse::RecDescent::_trace(q{Trying rule: [preScripted]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{preScripted},
                  $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::Expectation(q{FLOATSUPERSCRIPT, or FLOATSUBSCRIPT, or <matchrule:$arg[0]>});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUPERSCRIPT inpreScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{preScripted});
        %item = (__RULE__ => q{preScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{preScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{preScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{preScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{inpreScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [inpreScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{preScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [inpreScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{inpreScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript($item[2],$item[1], 'pre');};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUPERSCRIPT inpreScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUBSCRIPT inpreScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{preScripted});
        %item = (__RULE__ => q{preScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{preScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{preScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{preScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{inpreScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [inpreScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{preScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [inpreScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{inpreScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript($item[2],$item[1], 'pre');};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUBSCRIPT inpreScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<matchrule:$arg[0]> addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{preScripted});
        %item = (__RULE__ => q{preScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [$arg[0]]},
                  Parse::RecDescent::_tracefirst($text),
                  q{preScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = &{'Parse::RecDescent::LaTeXML::MathGrammar::'.qq{$arg[0]}}($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [$arg[0]]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{preScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [$arg[0]]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{$arg[0]}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{preScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{preScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [<matchrule:$arg[0]> addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{preScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{preScripted},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{preScripted},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{preScripted},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{preScripted},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"inpreScripted"};

    Parse::RecDescent::_trace(q{Trying rule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{inpreScripted},
                  $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::Expectation(q{POSTSUPERSCRIPT, or POSTSUBSCRIPT, or FLOATSUPERSCRIPT, or FLOATSUBSCRIPT, or <matchrule:$arg[0]>});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUPERSCRIPT inpreScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{inpreScripted});
        %item = (__RULE__ => q{inpreScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{inpreScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [inpreScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [inpreScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{inpreScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript($item[2],$item[1], 'pre');};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUPERSCRIPT inpreScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUBSCRIPT inpreScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{inpreScripted});
        %item = (__RULE__ => q{inpreScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{inpreScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [inpreScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [inpreScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{inpreScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript($item[2],$item[1], 'pre');};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUBSCRIPT inpreScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUPERSCRIPT inpreScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{inpreScripted});
        %item = (__RULE__ => q{inpreScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{inpreScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [inpreScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [inpreScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{inpreScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript($item[2],$item[1], 'pre');};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUPERSCRIPT inpreScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [FLOATSUBSCRIPT inpreScripted]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{inpreScripted});
        %item = (__RULE__ => q{inpreScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [FLOATSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::FLOATSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [FLOATSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [FLOATSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{FLOATSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [inpreScripted]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{inpreScripted})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::inpreScripted($thisparser,$text,$repeating,$_noactions,sub { return [$arg[0]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [inpreScripted]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [inpreScripted]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{inpreScripted}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewScript($item[2],$item[1], 'pre');};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [FLOATSUBSCRIPT inpreScripted]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [<matchrule:$arg[0]> addScripts]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[4];
        $text = $_[1];
        my $_savetext;
        @item = (q{inpreScripted});
        %item = (__RULE__ => q{inpreScripted});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [$arg[0]]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = &{'Parse::RecDescent::LaTeXML::MathGrammar::'.qq{$arg[0]}}($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [$arg[0]]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [$arg[0]]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{$arg[0]}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addScripts]},
                  Parse::RecDescent::_tracefirst($text),
                  q{inpreScripted},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addScripts})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addScripts($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addScripts]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{inpreScripted},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addScripts]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addScripts}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [<matchrule:$arg[0]> addScripts]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{inpreScripted},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{inpreScripted},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{inpreScripted},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{inpreScripted},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{inpreScripted},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::DIFFOP
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"DIFFOP"};

    Parse::RecDescent::_trace(q{Trying rule: [DIFFOP]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{DIFFOP},
                  $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::Expectation(q{/DIFFOP:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/DIFFOP:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{DIFFOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{DIFFOP});
        %item = (__RULE__ => q{DIFFOP});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/DIFFOP:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{DIFFOP},
                      $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(?:DIFFOP:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{DIFFOP},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/DIFFOP:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{DIFFOP},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{DIFFOP},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{DIFFOP},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{DIFFOP},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{DIFFOP},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::ATOM_OR_ID
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"ATOM_OR_ID"};

    Parse::RecDescent::_trace(q{Trying rule: [ATOM_OR_ID]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ATOM_OR_ID},
                  $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::Expectation(q{ATOM, or ID, or ARRAY});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ATOM]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{ATOM_OR_ID});
        %item = (__RULE__ => q{ATOM_OR_ID});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ATOM]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ATOM_OR_ID},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ATOM($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ATOM]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ATOM_OR_ID},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ATOM]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ATOM}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [ATOM]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ID]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{ATOM_OR_ID});
        %item = (__RULE__ => q{ATOM_OR_ID});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ID]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ATOM_OR_ID},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ID($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ID]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ATOM_OR_ID},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ID]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ID}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [ID]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ARRAY]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{ATOM_OR_ID});
        %item = (__RULE__ => q{ATOM_OR_ID});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ARRAY]},
                  Parse::RecDescent::_tracefirst($text),
                  q{ATOM_OR_ID},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ARRAY($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ARRAY]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{ATOM_OR_ID},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ARRAY]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ARRAY}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [ARRAY]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ATOM_OR_ID},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ATOM_OR_ID},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ATOM_OR_ID},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ATOM_OR_ID},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ATOM_OR_ID},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::ID
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"ID"};

    Parse::RecDescent::_trace(q{Trying rule: [ID]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{ID},
                  $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::Expectation(q{/ID:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/ID:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{ID});
        %item = (__RULE__ => q{ID});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/ID:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{ID},
                      $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(?:ID:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{ID},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/ID:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{ID},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{ID},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{ID},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{ID},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{ID},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"addOpDecoration"};

    Parse::RecDescent::_trace(q{Trying rule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{addOpDecoration},
                  $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::Expectation(q{/^\\Z/, or POSTSUPERSCRIPT, or POSTSUBSCRIPT});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpDecoration});
        %item = (__RULE__ => q{addOpDecoration});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0];};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUPERSCRIPT addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpDecoration});
        %item = (__RULE__ => q{addOpDecoration});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUPERSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpDecoration},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUPERSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUPERSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpDecoration},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUPERSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUPERSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpDecoration},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [DecorateOperator($arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpDecoration},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpDecoration}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUPERSCRIPT addOpDecoration]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [POSTSUBSCRIPT addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpDecoration});
        %item = (__RULE__ => q{addOpDecoration});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [POSTSUBSCRIPT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpDecoration},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::POSTSUBSCRIPT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [POSTSUBSCRIPT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpDecoration},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [POSTSUBSCRIPT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{POSTSUBSCRIPT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{addOpDecoration},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [DecorateOperator($arg[0],$item[1])] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{addOpDecoration},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpDecoration}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [POSTSUBSCRIPT addOpDecoration]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[3];
        $text = $_[1];
        my $_savetext;
        @item = (q{addOpDecoration});
        %item = (__RULE__ => q{addOpDecoration});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { $arg[0]; };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{addOpDecoration},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{addOpDecoration},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{addOpDecoration},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{addOpDecoration},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{addOpDecoration},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::moreRHS
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"moreRHS"};

    Parse::RecDescent::_trace(q{Trying rule: [moreRHS]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreRHS},
                  $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::Expectation(q{/^\\Z/, or PUNCT, or relopExpr});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreRHS});
        %item = (__RULE__ => q{moreRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $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::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewFormula($arg[0],$arg[1],$arg[2]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [PUNCT Expression maybeColRHS]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreRHS});
        %item = (__RULE__ => q{moreRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [PUNCT]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::PUNCT($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [PUNCT]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [PUNCT]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{PUNCT}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [maybeColRHS]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{maybeColRHS})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::maybeColRHS($thisparser,$text,$repeating,$_noactions,sub { return [@arg,$item[1],$item[2]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [maybeColRHS]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [maybeColRHS]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{maybeColRHS}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [PUNCT Expression maybeColRHS]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [relopExpr]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreRHS});
        %item = (__RULE__ => q{moreRHS});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying repeated subrule: [relopExpr]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreRHS},
                  $tracelevel)
                    if defined $::RD_TRACE;
        $expectation->is(q{})->at($text);
        
        unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::LaTeXML::MathGrammar::relopExpr, 0, 100000000, $_noactions,$expectation,sub { \@arg },undef)))
        {
            Parse::RecDescent::_trace(q{<<Didn't match repeated subrule: [relopExpr]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreRHS},
                          $tracelevel)
                            if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched repeated subrule: [relopExpr]<< (}
                    . @$_tok . q{ times)},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{relopExpr(s?)}} = $_tok;
        push @item, $_tok;
        


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { NewFormula($arg[0],$arg[1],$arg[2],
                                     map(@$_,@{$item[1]})); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [relopExpr]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreRHS},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreRHS},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreRHS},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreRHS},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreRHS},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::operator
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"operator"};

    Parse::RecDescent::_trace(q{Trying rule: [operator]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{operator},
                  $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::Expectation(q{OPERATOR});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [OPERATOR]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{operator},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{operator});
        %item = (__RULE__ => q{operator});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [OPERATOR]},
                  Parse::RecDescent::_tracefirst($text),
                  q{operator},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::OPERATOR($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [OPERATOR]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{operator},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [OPERATOR]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{operator},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{OPERATOR}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [OPERATOR]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{operator},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{operator},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{operator},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{operator},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{operator},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::aSubscript
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"aSubscript"};

    Parse::RecDescent::_trace(q{Trying rule: [aSubscript]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{aSubscript},
                  $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::Expectation(q{Formulae, or AnyOp});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Formulae]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{aSubscript});
        %item = (__RULE__ => q{aSubscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Formulae]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSubscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Formulae($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Formulae]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSubscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Formulae]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Formulae}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [Formulae]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp Expression]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{aSubscript});
        %item = (__RULE__ => q{aSubscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSubscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSubscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AnyOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [Expression]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSubscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{Expression})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Expression($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Expression]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSubscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Expression]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Expression}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Apply($item[1],Absent(),$item[2]);};
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [AnyOp Expression]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [AnyOp]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[2];
        $text = $_[1];
        my $_savetext;
        @item = (q{aSubscript});
        %item = (__RULE__ => q{aSubscript});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [AnyOp]},
                  Parse::RecDescent::_tracefirst($text),
                  q{aSubscript},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::AnyOp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [AnyOp]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{aSubscript},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [AnyOp]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{AnyOp}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [AnyOp]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{aSubscript},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{aSubscript},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{aSubscript},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{aSubscript},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{aSubscript},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::AddOp
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"AddOp"};

    Parse::RecDescent::_trace(q{Trying rule: [AddOp]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{AddOp},
                  $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::Expectation(q{BINOP, or ADDOP});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [BINOP addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{AddOp});
        %item = (__RULE__ => q{AddOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [BINOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AddOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::BINOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [BINOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AddOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [BINOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{BINOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AddOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AddOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpDecoration}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [BINOP addOpDecoration]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [ADDOP addOpDecoration]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{AddOp});
        %item = (__RULE__ => q{AddOp});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [ADDOP]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AddOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::ADDOP($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [ADDOP]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AddOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [ADDOP]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{ADDOP}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [addOpDecoration]},
                  Parse::RecDescent::_tracefirst($text),
                  q{AddOp},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{addOpDecoration})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::addOpDecoration($thisparser,$text,$repeating,$_noactions,sub { return [$item[1]] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [addOpDecoration]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{AddOp},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [addOpDecoration]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{addOpDecoration}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [ADDOP addOpDecoration]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{AddOp},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{AddOp},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{AddOp},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{AddOp},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{AddOp},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::PERIOD
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"PERIOD"};

    Parse::RecDescent::_trace(q{Trying rule: [PERIOD]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{PERIOD},
                  $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::Expectation(q{/PERIOD:\\S*:\\d+/});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [/PERIOD:\\S*:\\d+/]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{PERIOD},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{PERIOD});
        %item = (__RULE__ => q{PERIOD});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying terminal: [/PERIOD:\\S*:\\d+/]}, Parse::RecDescent::_tracefirst($text),
                      q{PERIOD},
                      $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(?:PERIOD:\S*:\d+)/)
        {
            $text = $lastsep . $text if defined $lastsep;
            $expectation->failed();
            Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;

            last;
        }
        $current_match = substr($text, $-[0], $+[0] - $-[0]);
        substr($text,0,length($current_match),q{});
        Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
                        . $current_match . q{])},
                          Parse::RecDescent::_tracefirst($text))
                    if defined $::RD_TRACE;
        push @item, $item{__PATTERN1__}=$current_match;
        

        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{PERIOD},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { Lookup($item[1]); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: [/PERIOD:\\S*:\\d+/]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{PERIOD},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{PERIOD},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{PERIOD},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{PERIOD},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{PERIOD},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}

# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
sub Parse::RecDescent::LaTeXML::MathGrammar::moreTerms2
{
	my $thisparser = $_[0];
	use vars q{$tracelevel};
	local $tracelevel = ($tracelevel||0)+1;
	$ERRORS = 0;
    my $thisrule = $thisparser->{"rules"}{"moreTerms2"};

    Parse::RecDescent::_trace(q{Trying rule: [moreTerms2]},
                  Parse::RecDescent::_tracefirst($_[1]),
                  q{moreTerms2},
                  $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::Expectation(q{Term});
    $expectation->at($_[1]);
    
    my $thisline;
    tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;

    

    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: [Term moreTerms]},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[0];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreTerms2});
        %item = (__RULE__ => q{moreTerms2});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying subrule: [Term]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTerms2},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::Term($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [Term]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTerms2},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [Term]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{Term}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{Trying subrule: [moreTerms]},
                  Parse::RecDescent::_tracefirst($text),
                  q{moreTerms2},
                  $tracelevel)
                    if defined $::RD_TRACE;
        if (1) { no strict qw{refs};
        $expectation->is(q{moreTerms})->at($text);
        unless (defined ($_tok = Parse::RecDescent::LaTeXML::MathGrammar::moreTerms($thisparser,$text,$repeating,$_noactions,sub { return [ [@{$arg[0]},$arg[1],$arg[2]],$item[1] ] },undef)))
        {
            
            Parse::RecDescent::_trace(q{<<Didn't match subrule: [moreTerms]>>},
                          Parse::RecDescent::_tracefirst($text),
                          q{moreTerms2},
                          $tracelevel)
                            if defined $::RD_TRACE;
            $expectation->failed();
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched subrule: [moreTerms]<< (return value: [}
                    . $_tok . q{]},

                      Parse::RecDescent::_tracefirst($text),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;
        $item{q{moreTerms}} = $_tok;
        push @item, $_tok;
        
        }

        Parse::RecDescent::_trace(q{>>Matched production: [Term moreTerms]<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    while (!$_matched && !$commit)
    {
        
        Parse::RecDescent::_trace(q{Trying production: []},
                      Parse::RecDescent::_tracefirst($_[1]),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;
        my $thisprod = $thisrule->{"prods"}[1];
        $text = $_[1];
        my $_savetext;
        @item = (q{moreTerms2});
        %item = (__RULE__ => q{moreTerms2});
        my $repcount = 0;


        Parse::RecDescent::_trace(q{Trying action},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;
        

        $_tok = ($_noactions) ? 0 : do { LeftRec(@{$arg[0]},Apply(New('limit-from'),$arg[1],$arg[2])); };
        unless (defined $_tok)
        {
            Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
                    if defined $::RD_TRACE;
            last;
        }
        Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
                      . $_tok . q{])},
                      Parse::RecDescent::_tracefirst($text))
                        if defined $::RD_TRACE;
        push @item, $_tok;
        $item{__ACTION1__}=$_tok;
        

        Parse::RecDescent::_trace(q{>>Matched production: []<<},
                      Parse::RecDescent::_tracefirst($text),
                      q{moreTerms2},
                      $tracelevel)
                        if defined $::RD_TRACE;



        $_matched = 1;
        last;
    }


    unless ( $_matched || defined($score) )
    {
        

        $_[1] = $text;  # NOT SURE THIS IS NEEDED
        Parse::RecDescent::_trace(q{<<Didn't match rule>>},
                     Parse::RecDescent::_tracefirst($_[1]),
                     q{moreTerms2},
                     $tracelevel)
                    if defined $::RD_TRACE;
        return undef;
    }
    if (!defined($return) && defined($score))
    {
        Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
                      q{moreTerms2},
                      $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::_trace(q{>>Matched rule<< (return value: [} .
                      $return . q{])}, "",
                      q{moreTerms2},
                      $tracelevel);
        Parse::RecDescent::_trace(q{(consumed: [} .
                      Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
                      Parse::RecDescent::_tracefirst($text),
                      , q{moreTerms2},
                      $tracelevel)
    }
    $_[1] = $text;
    return $return;
}
}
package LaTeXML::MathGrammar; sub new { my $self = bless( {
                 'namespace' => 'Parse::RecDescent::LaTeXML::MathGrammar',
                 'startcode' => '',
                 'rules' => {
                              'POSTSUPERSCRIPT' => bless( {
                                                            'impcount' => 0,
                                                            'name' => 'POSTSUPERSCRIPT',
                                                            'prods' => [
                                                                         bless( {
                                                                                  'actcount' => 1,
                                                                                  'strcount' => 0,
                                                                                  'number' => 0,
                                                                                  'uncommit' => undef,
                                                                                  'line' => undef,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'mod' => '',
                                                                                                        'lookahead' => 0,
                                                                                                        'description' => '/POSTSUPERSCRIPT:\\\\S*:\\\\d+/',
                                                                                                        'line' => 786,
                                                                                                        'pattern' => 'POSTSUPERSCRIPT:\\S*:\\d+',
                                                                                                        'rdelim' => '/',
                                                                                                        'ldelim' => '/',
                                                                                                        'hashname' => '__PATTERN1__'
                                                                                                      }, 'Parse::RecDescent::Token' ),
                                                                                               bless( {
                                                                                                        'hashname' => '__ACTION1__',
                                                                                                        'code' => '{ Lookup($item[1]); }',
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 786
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ],
                                                                                  'patcount' => 1,
                                                                                  'dircount' => 0,
                                                                                  'error' => undef
                                                                                }, 'Parse::RecDescent::Production' )
                                                                       ],
                                                            'calls' => [],
                                                            'changed' => 0,
                                                            'vars' => '',
                                                            'line' => 786,
                                                            'opcount' => 0
                                                          }, 'Parse::RecDescent::Rule' ),
                              'evalAtOp' => bless( {
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'line' => 711,
                                                     'impcount' => 0,
                                                     'calls' => [
                                                                  'VERTBAR'
                                                                ],
                                                     'prods' => [
                                                                  bless( {
                                                                           'strcount' => 0,
                                                                           'actcount' => 0,
                                                                           'number' => 0,
                                                                           'line' => undef,
                                                                           'uncommit' => undef,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'subrule' => 'VERTBAR',
                                                                                                 'matchrule' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 712
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'number' => 1,
                                                                           'uncommit' => undef,
                                                                           'line' => 713,
                                                                           'actcount' => 1,
                                                                           'strcount' => 0,
                                                                           'patcount' => 1,
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'hashname' => '__PATTERN1__',
                                                                                                 'mod' => '',
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 713,
                                                                                                 'description' => '/CLOSE:\\\\|:\\\\d+/',
                                                                                                 'pattern' => 'CLOSE:\\|:\\d+',
                                                                                                 'ldelim' => '/',
                                                                                                 'rdelim' => '/'
                                                                                               }, 'Parse::RecDescent::Token' ),
                                                                                        bless( {
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'code' => '{ Lookup($item[1]); }',
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 713
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ]
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'name' => 'evalAtOp',
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'anyOpIsolator' => bless( {
                                                          'calls' => [
                                                                       'PUNCT',
                                                                       'CLOSE'
                                                                     ],
                                                          'name' => 'anyOpIsolator',
                                                          'prods' => [
                                                                       bless( {
                                                                                'patcount' => 1,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'pattern' => '^\\Z',
                                                                                                      'rdelim' => '/',
                                                                                                      'ldelim' => '/',
                                                                                                      'lookahead' => 0,
                                                                                                      'mod' => '',
                                                                                                      'description' => '/^\\\\Z/',
                                                                                                      'line' => 204,
                                                                                                      'hashname' => '__PATTERN1__'
                                                                                                    }, 'Parse::RecDescent::Token' )
                                                                                           ],
                                                                                'number' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'uncommit' => undef,
                                                                                'line' => 204,
                                                                                'number' => 1,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 204,
                                                                                                      'subrule' => 'PUNCT',
                                                                                                      'matchrule' => 0,
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'CLOSE',
                                                                                                      'line' => 204,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'number' => 2,
                                                                                'uncommit' => undef,
                                                                                'line' => 204,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'impcount' => 0,
                                                          'line' => 204,
                                                          'vars' => '',
                                                          'changed' => 0,
                                                          'opcount' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'relop' => bless( {
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'line' => 688,
                                                  'impcount' => 0,
                                                  'calls' => [
                                                               'RELOP',
                                                               'addOpDecoration',
                                                               'ARROW'
                                                             ],
                                                  'name' => 'relop',
                                                  'prods' => [
                                                               bless( {
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 690,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{ ($forbidLRAngle ? 1 : undef); }',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::Action' ),
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'mod' => '',
                                                                                              'lookahead' => 0,
                                                                                              'description' => '/RELOP:(less|greater)-than:\\\\d+/',
                                                                                              'line' => 690,
                                                                                              'pattern' => 'RELOP:(less|greater)-than:\\d+',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'hashname' => '__DIRECTIVE1__',
                                                                                              'code' => '$commit = 1',
                                                                                              'name' => '<commit>',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 690
                                                                                            }, 'Parse::RecDescent::Directive' ),
                                                                                     bless( {
                                                                                              'hashname' => '__DIRECTIVE2__',
                                                                                              'name' => '<reject>',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 690
                                                                                            }, 'Parse::RecDescent::UncondReject' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'dircount' => 2,
                                                                        'error' => undef
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'patcount' => 0,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'subrule' => 'RELOP',
                                                                                              'matchrule' => 0,
                                                                                              'line' => 691,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 691,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'addOpDecoration',
                                                                                              'argcode' => '[$item[1]]',
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'number' => 1,
                                                                        'line' => 691,
                                                                        'uncommit' => undef,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'ARROW',
                                                                                              'line' => 692,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'line' => 692,
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => '[$item[1]]',
                                                                                              'implicit' => undef,
                                                                                              'subrule' => 'addOpDecoration',
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0,
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => 692,
                                                                        'number' => 2
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'factorOpen' => bless( {
                                                       'line' => 437,
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'name' => 'factorOpen',
                                                       'prods' => [
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'AddOp',
                                                                                                   'line' => 439,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 439,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => '[$arg[0]]',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'balancedClose'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[Fence($arg[0],$item[1],$item[2])]',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 439
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'error' => undef,
                                                                             'dircount' => 0,
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'number' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'subrule' => 'preScripted',
                                                                                                   'matchrule' => 0,
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[\'bigop\']',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 441
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'subrule' => 'balancedClose',
                                                                                                   'matchrule' => 0,
                                                                                                   'argcode' => '[$arg[0]]',
                                                                                                   'implicit' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 441
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'argcode' => '[Fence($arg[0],$item[1],$item[2])]',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'line' => 442,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 442,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'Factor',
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ Apply($item[3],$item[4]); }',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 443
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'number' => 1,
                                                                             'uncommit' => undef,
                                                                             'line' => 440
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'strcount' => 0,
                                                                             'actcount' => 1,
                                                                             'line' => 444,
                                                                             'uncommit' => undef,
                                                                             'number' => 2,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 445,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'subrule' => 'Factor',
                                                                                                   'matchrule' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 445,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => '[\'bigop\']',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'preScripted'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 445,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => '[$arg[0]]',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'balancedClose'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'argcode' => '[Fence($arg[0],
                        Apply(InvisibleTimes(),$item[1],$item[2]),$item[3])]',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'line' => 446,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 447,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'Factor'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 448,
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ Apply($item[4],$item[5]); }'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'Expression',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 450
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'factorOpenExpr',
                                                                                                   'argcode' => '[$arg[0],$item[1]]',
                                                                                                   'implicit' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 450
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'uncommit' => undef,
                                                                             'line' => 449,
                                                                             'number' => 3,
                                                                             'actcount' => 0,
                                                                             'strcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'number' => 4,
                                                                             'uncommit' => undef,
                                                                             'line' => 451,
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'patcount' => 0,
                                                                             'error' => undef,
                                                                             'dircount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'argcode' => '[$arg[0]]',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'balancedClose',
                                                                                                   'line' => 452,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'matchrule' => 0,
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[Fence($arg[0],$item[1])]',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 452
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ]
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'number' => 5,
                                                                             'uncommit' => undef,
                                                                             'line' => 453,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 454,
                                                                                                   'lookahead' => 0,
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'AnyOp'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 454,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'factorOpenExpr',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[$arg[0],$item[1]]'
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'error' => undef,
                                                                             'dircount' => 0
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'calls' => [
                                                                    'AddOp',
                                                                    'balancedClose',
                                                                    'addScripts',
                                                                    'preScripted',
                                                                    'Factor',
                                                                    'Expression',
                                                                    'factorOpenExpr',
                                                                    'AnyOp'
                                                                  ],
                                                       'impcount' => 0,
                                                       'opcount' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'moreTrigBareargs' => bless( {
                                                             'opcount' => 0,
                                                             'impcount' => 0,
                                                             'calls' => [
                                                                          'MulOp',
                                                                          'aTrigBarearg',
                                                                          'moreTrigBareargs'
                                                                        ],
                                                             'prods' => [
                                                                          bless( {
                                                                                   'patcount' => 1,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'lookahead' => 0,
                                                                                                         'mod' => '',
                                                                                                         'description' => '/^\\\\Z/',
                                                                                                         'line' => 341,
                                                                                                         'pattern' => '^\\Z',
                                                                                                         'rdelim' => '/',
                                                                                                         'ldelim' => '/',
                                                                                                         'hashname' => '__PATTERN1__'
                                                                                                       }, 'Parse::RecDescent::Token' ),
                                                                                                bless( {
                                                                                                         'line' => 341,
                                                                                                         'lookahead' => 0,
                                                                                                         'code' => '{ $arg[0];}',
                                                                                                         'hashname' => '__ACTION1__'
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ],
                                                                                   'number' => 0,
                                                                                   'line' => undef,
                                                                                   'uncommit' => undef,
                                                                                   'strcount' => 0,
                                                                                   'actcount' => 1
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'uncommit' => undef,
                                                                                   'line' => 341,
                                                                                   'number' => 1,
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 0,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'subrule' => 'MulOp',
                                                                                                         'matchrule' => 0,
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 342
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef,
                                                                                                         'subrule' => 'aTrigBarearg',
                                                                                                         'matchrule' => 0,
                                                                                                         'line' => 342,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'subrule' => 'moreTrigBareargs',
                                                                                                         'matchrule' => 0,
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => '[ApplyNary($item[1],$arg[0],$item[2])]',
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 343
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ]
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 344,
                                                                                                         'subrule' => 'aTrigBarearg',
                                                                                                         'matchrule' => 0,
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'argcode' => '[ApplyNary(InvisibleTimes(),$arg[0],$item[1])]',
                                                                                                         'implicit' => undef,
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'moreTrigBareargs',
                                                                                                         'line' => 345,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ],
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 0,
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'uncommit' => undef,
                                                                                   'line' => 344,
                                                                                   'number' => 2
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 0,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'line' => 346,
                                                                                                         'lookahead' => 0,
                                                                                                         'code' => '{ $arg[0]; }',
                                                                                                         'hashname' => '__ACTION1__'
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ],
                                                                                   'uncommit' => undef,
                                                                                   'line' => 346,
                                                                                   'number' => 3,
                                                                                   'actcount' => 1,
                                                                                   'strcount' => 0
                                                                                 }, 'Parse::RecDescent::Production' )
                                                                        ],
                                                             'name' => 'moreTrigBareargs',
                                                             'vars' => '',
                                                             'changed' => 0,
                                                             'line' => 339
                                                           }, 'Parse::RecDescent::Rule' ),
                              'nestOperators' => bless( {
                                                          'changed' => 0,
                                                          'vars' => '',
                                                          'line' => 644,
                                                          'impcount' => 0,
                                                          'name' => 'nestOperators',
                                                          'prods' => [
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'hashname' => '__PATTERN1__',
                                                                                                      'description' => '/^\\\\Z/',
                                                                                                      'line' => 646,
                                                                                                      'mod' => '',
                                                                                                      'lookahead' => 0,
                                                                                                      'ldelim' => '/',
                                                                                                      'rdelim' => '/',
                                                                                                      'pattern' => '^\\Z'
                                                                                                    }, 'Parse::RecDescent::Token' ),
                                                                                             bless( {
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ recApply(@arg); }',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 646
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 1,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'number' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'subrule' => 'OPERATOR',
                                                                                                      'matchrule' => 0,
                                                                                                      'line' => 647,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'subrule' => 'addScripts',
                                                                                                      'matchrule' => 0,
                                                                                                      'argcode' => '[$item[1]]',
                                                                                                      'implicit' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 647
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'subrule' => 'nestOperators',
                                                                                                      'matchrule' => 0,
                                                                                                      'argcode' => '[@arg,$item[2]]',
                                                                                                      'implicit' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 647
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'strcount' => 0,
                                                                                'actcount' => 0,
                                                                                'number' => 1,
                                                                                'line' => 647,
                                                                                'uncommit' => undef
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => 648,
                                                                                'number' => 2,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 648,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'FUNCTION'
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 648,
                                                                                                      'subrule' => 'addScripts',
                                                                                                      'matchrule' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$item[1]]'
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'line' => 648,
                                                                                                      'lookahead' => 0,
                                                                                                      'code' => '{ recApply(@arg,$item[2]); }',
                                                                                                      'hashname' => '__ACTION1__'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'OPFUNCTION',
                                                                                                      'line' => 649,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'line' => 649,
                                                                                                      'lookahead' => 0,
                                                                                                      'argcode' => '[$item[1]]',
                                                                                                      'implicit' => undef,
                                                                                                      'subrule' => 'addScripts',
                                                                                                      'matchrule' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 649,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ recApply(@arg,$item[2]); }'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'uncommit' => undef,
                                                                                'line' => 649,
                                                                                'number' => 3,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 650,
                                                                                                      'lookahead' => 0,
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'TRIGFUNCTION'
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'addScripts',
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$item[1]]',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 650
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ recApply(@arg,$item[2]); }',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 650
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1,
                                                                                'line' => 650,
                                                                                'uncommit' => undef,
                                                                                'number' => 4
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'number' => 5,
                                                                                'uncommit' => undef,
                                                                                'line' => 651,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'OPEN',
                                                                                                      'line' => 651,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'line' => 651,
                                                                                                      'lookahead' => 0,
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'Expression'
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'balancedClose',
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$item[1]]',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 651
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ recApply(@arg[0..$#arg-1],
                        ApplyDelimited($arg[$#arg],$item[1],$item[2],$item[3])); }',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 652
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'number' => 6,
                                                                                'uncommit' => undef,
                                                                                'line' => 654,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ recApply(@arg); }',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 654
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'calls' => [
                                                                       'OPERATOR',
                                                                       'addScripts',
                                                                       'nestOperators',
                                                                       'FUNCTION',
                                                                       'OPFUNCTION',
                                                                       'TRIGFUNCTION',
                                                                       'OPEN',
                                                                       'Expression',
                                                                       'balancedClose'
                                                                     ],
                                                          'opcount' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'Formulae' => bless( {
                                                     'impcount' => 0,
                                                     'name' => 'Formulae',
                                                     'prods' => [
                                                                  bless( {
                                                                           'uncommit' => undef,
                                                                           'line' => undef,
                                                                           'number' => 0,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'patcount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'Formula',
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 116
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'line' => 116,
                                                                                                 'lookahead' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]',
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'moreFormulae'
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ]
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'calls' => [
                                                                  'Formula',
                                                                  'moreFormulae'
                                                                ],
                                                     'changed' => 0,
                                                     'vars' => '',
                                                     'line' => 114,
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'METARELOP' => bless( {
                                                      'opcount' => 0,
                                                      'calls' => [],
                                                      'prods' => [
                                                                   bless( {
                                                                            'number' => 0,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'patcount' => 1,
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__PATTERN1__',
                                                                                                  'description' => '/METARELOP:\\\\S*:\\\\d+/',
                                                                                                  'line' => 758,
                                                                                                  'mod' => '',
                                                                                                  'lookahead' => 0,
                                                                                                  'ldelim' => '/',
                                                                                                  'rdelim' => '/',
                                                                                                  'pattern' => 'METARELOP:\\S*:\\d+'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'line' => 758,
                                                                                                  'lookahead' => 0,
                                                                                                  'code' => '{ Lookup($item[1]); }',
                                                                                                  'hashname' => '__ACTION1__'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ]
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'name' => 'METARELOP',
                                                      'impcount' => 0,
                                                      'line' => 758,
                                                      'vars' => '',
                                                      'changed' => 0
                                                    }, 'Parse::RecDescent::Rule' ),
                              'maybeEvalAt' => bless( {
                                                        'vars' => '',
                                                        'changed' => 0,
                                                        'line' => 348,
                                                        'impcount' => 0,
                                                        'calls' => [
                                                                     'POSTSUBSCRIPT',
                                                                     'moreEvalAt',
                                                                     'POSTSUPERSCRIPT',
                                                                     'moreFactors'
                                                                   ],
                                                        'name' => 'maybeEvalAt',
                                                        'prods' => [
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 350,
                                                                                                    'subrule' => 'POSTSUBSCRIPT',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[$arg[0],$arg[1],$item[1]]',
                                                                                                    'subrule' => 'moreEvalAt',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 350,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0,
                                                                              'number' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 351,
                                                                                                    'subrule' => 'POSTSUPERSCRIPT',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'POSTSUBSCRIPT',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 351,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 351,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[NewEvalAt($arg[0],$arg[1],$item[2],$item[1])]',
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'moreFactors'
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'strcount' => 0,
                                                                              'actcount' => 0,
                                                                              'line' => 351,
                                                                              'uncommit' => undef,
                                                                              'number' => 1
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              'suchThatOp' => bless( {
                                                       'line' => 482,
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'name' => 'suchThatOp',
                                                       'prods' => [
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'MIDDLE',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 483
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'strcount' => 0,
                                                                             'actcount' => 0,
                                                                             'number' => 0,
                                                                             'line' => undef,
                                                                             'uncommit' => undef
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => 483,
                                                                             'number' => 1,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'VERTBAR',
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 483
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'error' => undef,
                                                                             'dircount' => 0,
                                                                             'patcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => 484,
                                                                             'number' => 2,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'hashname' => '__PATTERN1__',
                                                                                                   'description' => '/METARELOP:colon:\\\\d+/',
                                                                                                   'line' => 484,
                                                                                                   'lookahead' => 0,
                                                                                                   'mod' => '',
                                                                                                   'ldelim' => '/',
                                                                                                   'rdelim' => '/',
                                                                                                   'pattern' => 'METARELOP:colon:\\d+'
                                                                                                 }, 'Parse::RecDescent::Token' ),
                                                                                          bless( {
                                                                                                   'line' => 484,
                                                                                                   'lookahead' => 0,
                                                                                                   'code' => '{ Lookup($item[1]); }',
                                                                                                   'hashname' => '__ACTION1__'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 1
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'calls' => [
                                                                    'MIDDLE',
                                                                    'VERTBAR'
                                                                  ],
                                                       'impcount' => 0,
                                                       'opcount' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'MODIFIEROP' => bless( {
                                                       'opcount' => 0,
                                                       'vars' => '',
                                                       'changed' => 0,
                                                       'line' => 759,
                                                       'impcount' => 0,
                                                       'calls' => [],
                                                       'prods' => [
                                                                    bless( {
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'number' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'mod' => '',
                                                                                                   'description' => '/MODIFIEROP:\\\\S*:\\\\d+/',
                                                                                                   'line' => 759,
                                                                                                   'pattern' => 'MODIFIEROP:\\S*:\\d+',
                                                                                                   'rdelim' => '/',
                                                                                                   'ldelim' => '/',
                                                                                                   'hashname' => '__PATTERN1__'
                                                                                                 }, 'Parse::RecDescent::Token' ),
                                                                                          bless( {
                                                                                                   'code' => '{ Lookup($item[1]); }',
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'line' => 759,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'patcount' => 1,
                                                                             'error' => undef,
                                                                             'dircount' => 0
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'MODIFIEROP'
                                                     }, 'Parse::RecDescent::Rule' ),
                              'Superscript' => bless( {
                                                        'name' => 'Superscript',
                                                        'prods' => [
                                                                     bless( {
                                                                              'patcount' => 0,
                                                                              'dircount' => 1,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'name' => '<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>',
                                                                                                    'hashname' => '__DIRECTIVE1__',
                                                                                                    'line' => 89,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::UncondReject' )
                                                                                         ],
                                                                              'number' => 0,
                                                                              'line' => undef,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 1,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 91,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'aSuperscript',
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'max' => 100000000,
                                                                                                    'min' => 0,
                                                                                                    'repspec' => 's?',
                                                                                                    'expected' => 'PUNCT',
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => '_alternation_1_of_production_2_of_rule_Superscript',
                                                                                                    'line' => 91,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
                                                                                           bless( {
                                                                                                    'line' => 92,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ NewList($item[1],map(@$_,@{$item[2]})); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'calls' => [
                                                                     'aSuperscript',
                                                                     '_alternation_1_of_production_2_of_rule_Superscript'
                                                                   ],
                                                        'impcount' => 1,
                                                        'line' => 89,
                                                        'changed' => 0,
                                                        'vars' => ' local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH;
',
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              'maybeBra' => bless( {
                                                     'opcount' => 0,
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'line' => 361,
                                                     'impcount' => 0,
                                                     'calls' => [
                                                                  'ketExpression',
                                                                  'maybeBraket',
                                                                  'addScripts'
                                                                ],
                                                     'name' => 'maybeBra',
                                                     'prods' => [
                                                                  bless( {
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 363,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'ketExpression',
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 363,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'maybeBraket',
                                                                                                 'argcode' => '[$arg[0],$arg[1],$arg[2],$item[1]]',
                                                                                                 'implicit' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'number' => 0,
                                                                           'line' => undef,
                                                                           'uncommit' => undef,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'actcount' => 1,
                                                                           'strcount' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => 364,
                                                                           'number' => 1,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'code' => '{ SawNotation(\'QM\'); }',
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'line' => 364,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Action' ),
                                                                                        bless( {
                                                                                                 'line' => 365,
                                                                                                 'lookahead' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[InterpretDelimited(New(\'bra\'),
                     Annotate($arg[0],role=>\'OPEN\'),$arg[1],Annotate($arg[2],role=>\'CLOSE\'))]',
                                                                                                 'subrule' => 'addScripts',
                                                                                                 'matchrule' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 0
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ]
                                                   }, 'Parse::RecDescent::Rule' ),
                              'scriptFactorOpen' => bless( {
                                                             'vars' => '',
                                                             'changed' => 0,
                                                             'line' => 473,
                                                             'impcount' => 0,
                                                             'calls' => [
                                                                          'Formula',
                                                                          'suchThatOp',
                                                                          'Formulae',
                                                                          'balancedClose',
                                                                          'addScripts',
                                                                          'factorOpen'
                                                                        ],
                                                             'prods' => [
                                                                          bless( {
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'subrule' => 'Formula',
                                                                                                         'matchrule' => 0,
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 475
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'line' => 475,
                                                                                                         'lookahead' => 0,
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef,
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'suchThatOp'
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'Formulae',
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 475
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 475,
                                                                                                         'subrule' => 'balancedClose',
                                                                                                         'matchrule' => 0,
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => '[$arg[0]]'
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'addScripts',
                                                                                                         'argcode' => '[InterpretDelimited(New(\'conditional-set\'),
                                    $arg[0], $item[1],$item[2], $item[3],$item[4])]',
                                                                                                         'implicit' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 476
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ],
                                                                                   'error' => undef,
                                                                                   'dircount' => 0,
                                                                                   'patcount' => 0,
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'uncommit' => undef,
                                                                                   'line' => undef,
                                                                                   'number' => 0
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'number' => 1,
                                                                                   'uncommit' => undef,
                                                                                   'line' => 478,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => '[$arg[0]]',
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'factorOpen',
                                                                                                         'line' => 479,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ],
                                                                                   'patcount' => 0,
                                                                                   'error' => undef,
                                                                                   'dircount' => 0
                                                                                 }, 'Parse::RecDescent::Production' )
                                                                        ],
                                                             'name' => 'scriptFactorOpen',
                                                             'opcount' => 0
                                                           }, 'Parse::RecDescent::Rule' ),
                              'moreTerms' => bless( {
                                                      'opcount' => 0,
                                                      'impcount' => 0,
                                                      'calls' => [
                                                                   'AddOp',
                                                                   'moreTerms2'
                                                                 ],
                                                      'prods' => [
                                                                   bless( {
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'number' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'pattern' => '^\\Z',
                                                                                                  'ldelim' => '/',
                                                                                                  'rdelim' => '/',
                                                                                                  'mod' => '',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 208,
                                                                                                  'description' => '/^\\\\Z/',
                                                                                                  'hashname' => '__PATTERN1__'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'code' => '{ LeftRec(@{$arg[0]},$arg[1]); }',
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'line' => 208,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 1
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'strcount' => 0,
                                                                            'actcount' => 0,
                                                                            'line' => 208,
                                                                            'uncommit' => undef,
                                                                            'number' => 1,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 209,
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'AddOp',
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'line' => 209,
                                                                                                  'lookahead' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => '[$arg[0],$arg[1],$item[1]]',
                                                                                                  'subrule' => 'moreTerms2',
                                                                                                  'matchrule' => 0
                                                                                                }, 'Parse::RecDescent::Subrule' )
                                                                                       ],
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'line' => 210,
                                                                                                  'lookahead' => 0,
                                                                                                  'code' => '{ LeftRec(@{$arg[0]},$arg[1]); }',
                                                                                                  'hashname' => '__ACTION1__'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'line' => 210,
                                                                            'uncommit' => undef,
                                                                            'number' => 2
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'name' => 'moreTerms',
                                                      'vars' => '',
                                                      'changed' => 0,
                                                      'line' => 206
                                                    }, 'Parse::RecDescent::Rule' ),
                              'UNKNOWN' => bless( {
                                                    'opcount' => 0,
                                                    'line' => 742,
                                                    'changed' => 0,
                                                    'vars' => '',
                                                    'name' => 'UNKNOWN',
                                                    'prods' => [
                                                                 bless( {
                                                                          'strcount' => 0,
                                                                          'actcount' => 1,
                                                                          'line' => undef,
                                                                          'uncommit' => undef,
                                                                          'number' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'pattern' => 'UNKNOWN:\\S*:\\d+',
                                                                                                'ldelim' => '/',
                                                                                                'rdelim' => '/',
                                                                                                'lookahead' => 0,
                                                                                                'mod' => '',
                                                                                                'description' => '/UNKNOWN:\\\\S*:\\\\d+/',
                                                                                                'line' => 742,
                                                                                                'hashname' => '__PATTERN1__'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 742,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ Lookup($item[1]); }'
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'error' => undef,
                                                                          'dircount' => 0,
                                                                          'patcount' => 1
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'calls' => [],
                                                    'impcount' => 0
                                                  }, 'Parse::RecDescent::Rule' ),
                              'ATOM' => bless( {
                                                 'impcount' => 0,
                                                 'prods' => [
                                                              bless( {
                                                                       'patcount' => 1,
                                                                       'error' => undef,
                                                                       'dircount' => 0,
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'rdelim' => '/',
                                                                                             'ldelim' => '/',
                                                                                             'pattern' => 'ATOM:\\S*:\\d+',
                                                                                             'line' => 741,
                                                                                             'description' => '/ATOM:\\\\S*:\\\\d+/',
                                                                                             'mod' => '',
                                                                                             'lookahead' => 0,
                                                                                             'hashname' => '__PATTERN1__'
                                                                                           }, 'Parse::RecDescent::Token' ),
                                                                                    bless( {
                                                                                             'lookahead' => 0,
                                                                                             'line' => 741,
                                                                                             'hashname' => '__ACTION1__',
                                                                                             'code' => '{ Lookup($item[1]); }'
                                                                                           }, 'Parse::RecDescent::Action' )
                                                                                  ],
                                                                       'number' => 0,
                                                                       'uncommit' => undef,
                                                                       'line' => undef,
                                                                       'actcount' => 1,
                                                                       'strcount' => 0
                                                                     }, 'Parse::RecDescent::Production' )
                                                            ],
                                                 'name' => 'ATOM',
                                                 'calls' => [],
                                                 'changed' => 0,
                                                 'vars' => '',
                                                 'line' => 739,
                                                 'opcount' => 0
                                               }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_1_of_rule_factorOpenExpr' => bless( {
                                                                                                  'changed' => 0,
                                                                                                  'vars' => '',
                                                                                                  'line' => 791,
                                                                                                  'impcount' => 0,
                                                                                                  'name' => '_alternation_1_of_production_1_of_rule_factorOpenExpr',
                                                                                                  'prods' => [
                                                                                                               bless( {
                                                                                                                        'actcount' => 1,
                                                                                                                        'strcount' => 0,
                                                                                                                        'uncommit' => undef,
                                                                                                                        'line' => undef,
                                                                                                                        'number' => 0,
                                                                                                                        'items' => [
                                                                                                                                     bless( {
                                                                                                                                              'matchrule' => 0,
                                                                                                                                              'subrule' => 'PUNCT',
                                                                                                                                              'implicit' => undef,
                                                                                                                                              'argcode' => undef,
                                                                                                                                              'lookahead' => 0,
                                                                                                                                              'line' => 791
                                                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                     bless( {
                                                                                                                                              'lookahead' => 0,
                                                                                                                                              'line' => 791,
                                                                                                                                              'matchrule' => 0,
                                                                                                                                              'subrule' => 'Expression',
                                                                                                                                              'argcode' => undef,
                                                                                                                                              'implicit' => undef
                                                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                     bless( {
                                                                                                                                              'line' => 791,
                                                                                                                                              'lookahead' => 0,
                                                                                                                                              'code' => '{ [$item[1],$item[2]]; }',
                                                                                                                                              'hashname' => '__ACTION1__'
                                                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                                                   ],
                                                                                                                        'dircount' => 0,
                                                                                                                        'error' => undef,
                                                                                                                        'patcount' => 0
                                                                                                                      }, 'Parse::RecDescent::Production' )
                                                                                                             ],
                                                                                                  'calls' => [
                                                                                                               'PUNCT',
                                                                                                               'Expression'
                                                                                                             ],
                                                                                                  'opcount' => 0
                                                                                                }, 'Parse::RecDescent::Rule' ),
                              'INTOP' => bless( {
                                                  'impcount' => 0,
                                                  'calls' => [],
                                                  'prods' => [
                                                               bless( {
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 1,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'mod' => '',
                                                                                              'lookahead' => 0,
                                                                                              'description' => '/INTOP:\\\\S*:\\\\d+/',
                                                                                              'line' => 780,
                                                                                              'pattern' => 'INTOP:\\S*:\\d+',
                                                                                              'ldelim' => '/',
                                                                                              'rdelim' => '/'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'line' => 780,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'INTOP',
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'line' => 780,
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'Argument' => bless( {
                                                     'changed' => 0,
                                                     'vars' => '',
                                                     'line' => 563,
                                                     'impcount' => 0,
                                                     'name' => 'Argument',
                                                     'prods' => [
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'Expression',
                                                                                                 'line' => 564,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]',
                                                                                                 'subrule' => 'extendArgument',
                                                                                                 'matchrule' => 0,
                                                                                                 'line' => 564,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 0,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => undef,
                                                                           'number' => 0
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'calls' => [
                                                                  'Expression',
                                                                  'extendArgument'
                                                                ],
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'modifierFormula' => bless( {
                                                            'line' => 188,
                                                            'vars' => '',
                                                            'changed' => 0,
                                                            'calls' => [
                                                                         'relop',
                                                                         'Expression',
                                                                         'moreRHS'
                                                                       ],
                                                            'prods' => [
                                                                         bless( {
                                                                                  'actcount' => 0,
                                                                                  'strcount' => 0,
                                                                                  'uncommit' => undef,
                                                                                  'line' => undef,
                                                                                  'number' => 0,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 188,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'relop',
                                                                                                        'implicit' => undef,
                                                                                                        'argcode' => undef
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'Expression',
                                                                                                        'implicit' => undef,
                                                                                                        'argcode' => undef,
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 188
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'moreRHS',
                                                                                                        'argcode' => '[Absent(),$item[1],$item[2]]',
                                                                                                        'implicit' => undef,
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 188
                                                                                                      }, 'Parse::RecDescent::Subrule' )
                                                                                             ],
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'patcount' => 0
                                                                                }, 'Parse::RecDescent::Production' )
                                                                       ],
                                                            'name' => 'modifierFormula',
                                                            'impcount' => 0,
                                                            'opcount' => 0
                                                          }, 'Parse::RecDescent::Rule' ),
                              'BIGOP' => bless( {
                                                  'opcount' => 0,
                                                  'name' => 'BIGOP',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'mod' => '',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 778,
                                                                                              'description' => '/BIGOP:\\\\S*:\\\\d+/',
                                                                                              'pattern' => 'BIGOP:\\S*:\\d+',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 778
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'calls' => [],
                                                  'impcount' => 0,
                                                  'line' => 778,
                                                  'changed' => 0,
                                                  'vars' => ''
                                                }, 'Parse::RecDescent::Rule' ),
                              'modifierFormulae' => bless( {
                                                             'opcount' => 0,
                                                             'impcount' => 0,
                                                             'prods' => [
                                                                          bless( {
                                                                                   'uncommit' => undef,
                                                                                   'line' => undef,
                                                                                   'number' => 0,
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 0,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef,
                                                                                                         'subrule' => 'modifierFormula',
                                                                                                         'matchrule' => 0,
                                                                                                         'line' => 187,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => '[$item[1]]',
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'moreFormulae',
                                                                                                         'line' => 187,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ]
                                                                                 }, 'Parse::RecDescent::Production' )
                                                                        ],
                                                             'name' => 'modifierFormulae',
                                                             'calls' => [
                                                                          'modifierFormula',
                                                                          'moreFormulae'
                                                                        ],
                                                             'changed' => 0,
                                                             'vars' => '',
                                                             'line' => 186
                                                           }, 'Parse::RecDescent::Rule' ),
                              'extendArgument' => bless( {
                                                           'name' => 'extendArgument',
                                                           'prods' => [
                                                                        bless( {
                                                                                 'line' => undef,
                                                                                 'uncommit' => undef,
                                                                                 'number' => 0,
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 1,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef,
                                                                                 'patcount' => 1,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'hashname' => '__PATTERN1__',
                                                                                                       'pattern' => '^\\Z',
                                                                                                       'rdelim' => '/',
                                                                                                       'ldelim' => '/',
                                                                                                       'lookahead' => 0,
                                                                                                       'mod' => '',
                                                                                                       'description' => '/^\\\\Z/',
                                                                                                       'line' => 569
                                                                                                     }, 'Parse::RecDescent::Token' ),
                                                                                              bless( {
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 569,
                                                                                                       'hashname' => '__ACTION1__',
                                                                                                       'code' => '{ $arg[0]; }'
                                                                                                     }, 'Parse::RecDescent::Action' )
                                                                                            ]
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 0,
                                                                                 'number' => 1,
                                                                                 'line' => 569,
                                                                                 'uncommit' => undef,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'min' => 1,
                                                                                                       'argcode' => undef,
                                                                                                       'max' => 100000000,
                                                                                                       'line' => 570,
                                                                                                       'lookahead' => 0,
                                                                                                       'repspec' => 's',
                                                                                                       'expected' => undef,
                                                                                                       'subrule' => 'relopExpr',
                                                                                                       'matchrule' => 0
                                                                                                     }, 'Parse::RecDescent::Repetition' ),
                                                                                              bless( {
                                                                                                       'argcode' => '[NewFormula($arg[0],map(@$_,@{$item[1]}))]',
                                                                                                       'implicit' => undef,
                                                                                                       'subrule' => 'extendArgument',
                                                                                                       'matchrule' => 0,
                                                                                                       'line' => 570,
                                                                                                       'lookahead' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' )
                                                                                            ],
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'number' => 2,
                                                                                 'uncommit' => undef,
                                                                                 'line' => 571,
                                                                                 'actcount' => 0,
                                                                                 'strcount' => 0,
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'line' => 571,
                                                                                                       'lookahead' => 0,
                                                                                                       'argcode' => undef,
                                                                                                       'implicit' => undef,
                                                                                                       'subrule' => 'METARELOP',
                                                                                                       'matchrule' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'argcode' => undef,
                                                                                                       'implicit' => undef,
                                                                                                       'subrule' => 'Formula',
                                                                                                       'matchrule' => 0,
                                                                                                       'line' => 571,
                                                                                                       'lookahead' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 571,
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'extendArgument',
                                                                                                       'implicit' => undef,
                                                                                                       'argcode' => '[Apply($item[1],$arg[0],$item[2])]'
                                                                                                     }, 'Parse::RecDescent::Subrule' )
                                                                                            ]
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 1,
                                                                                 'number' => 3,
                                                                                 'line' => 572,
                                                                                 'uncommit' => undef,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'line' => 572,
                                                                                                       'lookahead' => 0,
                                                                                                       'code' => '{ $arg[0]; }',
                                                                                                       'hashname' => '__ACTION1__'
                                                                                                     }, 'Parse::RecDescent::Action' )
                                                                                            ],
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef
                                                                               }, 'Parse::RecDescent::Production' )
                                                                      ],
                                                           'calls' => [
                                                                        'relopExpr',
                                                                        'extendArgument',
                                                                        'METARELOP',
                                                                        'Formula'
                                                                      ],
                                                           'impcount' => 0,
                                                           'line' => 567,
                                                           'changed' => 0,
                                                           'vars' => '',
                                                           'opcount' => 0
                                                         }, 'Parse::RecDescent::Rule' ),
                              'trigBarearg' => bless( {
                                                        'opcount' => 0,
                                                        'impcount' => 0,
                                                        'calls' => [
                                                                     'aTrigBarearg',
                                                                     'moreTrigBareargs'
                                                                   ],
                                                        'prods' => [
                                                                     bless( {
                                                                              'number' => 0,
                                                                              'line' => undef,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 0,
                                                                              'patcount' => 0,
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'subrule' => 'aTrigBarearg',
                                                                                                    'matchrule' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 330
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 330,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => '[$item[1]]',
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'moreTrigBareargs',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'name' => 'trigBarearg',
                                                        'vars' => '',
                                                        'changed' => 0,
                                                        'line' => 329
                                                      }, 'Parse::RecDescent::Rule' ),
                              'moreBareargs' => bless( {
                                                         'calls' => [
                                                                      'MulOp',
                                                                      'aBarearg',
                                                                      'moreBareargs'
                                                                    ],
                                                         'prods' => [
                                                                      bless( {
                                                                               'actcount' => 1,
                                                                               'strcount' => 0,
                                                                               'number' => 0,
                                                                               'uncommit' => undef,
                                                                               'line' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'pattern' => '^\\Z',
                                                                                                     'rdelim' => '/',
                                                                                                     'ldelim' => '/',
                                                                                                     'mod' => '',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 324,
                                                                                                     'description' => '/^\\\\Z/',
                                                                                                     'hashname' => '__PATTERN1__'
                                                                                                   }, 'Parse::RecDescent::Token' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 324,
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ $arg[0];}'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'patcount' => 1,
                                                                               'error' => undef,
                                                                               'dircount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'line' => 325,
                                                                                                     'lookahead' => 0,
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => undef,
                                                                                                     'subrule' => 'MulOp',
                                                                                                     'matchrule' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 325,
                                                                                                     'subrule' => 'aBarearg',
                                                                                                     'matchrule' => 0,
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'subrule' => 'moreBareargs',
                                                                                                     'matchrule' => 0,
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => '[ApplyNary($item[1],$arg[0],$item[2])]',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 325
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'number' => 1,
                                                                               'uncommit' => undef,
                                                                               'line' => 324,
                                                                               'actcount' => 0,
                                                                               'strcount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'number' => 2,
                                                                               'uncommit' => undef,
                                                                               'line' => 326,
                                                                               'actcount' => 0,
                                                                               'strcount' => 0,
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => undef,
                                                                                                     'subrule' => 'aBarearg',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 326,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'argcode' => '[ApplyNary(InvisibleTimes(),$arg[0],$item[1])]',
                                                                                                     'implicit' => undef,
                                                                                                     'subrule' => 'moreBareargs',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 326,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'number' => 3,
                                                                               'line' => 327,
                                                                               'uncommit' => undef,
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 327,
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ $arg[0]; }'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'name' => 'moreBareargs',
                                                         'impcount' => 0,
                                                         'line' => 322,
                                                         'vars' => '',
                                                         'changed' => 0,
                                                         'opcount' => 0
                                                       }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_2_of_rule_moreFormulae' => bless( {
                                                                                                'opcount' => 0,
                                                                                                'impcount' => 0,
                                                                                                'calls' => [
                                                                                                             'endPunct',
                                                                                                             'Formula'
                                                                                                           ],
                                                                                                'name' => '_alternation_1_of_production_2_of_rule_moreFormulae',
                                                                                                'prods' => [
                                                                                                             bless( {
                                                                                                                      'actcount' => 1,
                                                                                                                      'strcount' => 0,
                                                                                                                      'number' => 0,
                                                                                                                      'uncommit' => undef,
                                                                                                                      'line' => undef,
                                                                                                                      'items' => [
                                                                                                                                   bless( {
                                                                                                                                            'implicit' => undef,
                                                                                                                                            'argcode' => undef,
                                                                                                                                            'matchrule' => 0,
                                                                                                                                            'subrule' => 'endPunct',
                                                                                                                                            'line' => 791,
                                                                                                                                            'lookahead' => 0
                                                                                                                                          }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                   bless( {
                                                                                                                                            'subrule' => 'Formula',
                                                                                                                                            'matchrule' => 0,
                                                                                                                                            'argcode' => undef,
                                                                                                                                            'implicit' => undef,
                                                                                                                                            'lookahead' => 0,
                                                                                                                                            'line' => 791
                                                                                                                                          }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                   bless( {
                                                                                                                                            'hashname' => '__ACTION1__',
                                                                                                                                            'code' => '{ [$item[1],$item[2]]; }',
                                                                                                                                            'lookahead' => 0,
                                                                                                                                            'line' => 791
                                                                                                                                          }, 'Parse::RecDescent::Action' )
                                                                                                                                 ],
                                                                                                                      'patcount' => 0,
                                                                                                                      'dircount' => 0,
                                                                                                                      'error' => undef
                                                                                                                    }, 'Parse::RecDescent::Production' )
                                                                                                           ],
                                                                                                'vars' => '',
                                                                                                'changed' => 0,
                                                                                                'line' => 791
                                                                                              }, 'Parse::RecDescent::Rule' ),
                              'Expression' => bless( {
                                                       'opcount' => 0,
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'line' => 198,
                                                       'impcount' => 0,
                                                       'prods' => [
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'number' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 198,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'SignedTerm',
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 198,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'moreTerms',
                                                                                                   'argcode' => '[[],$item[1]]',
                                                                                                   'implicit' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'addExpressionModifier',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[$item[2]]',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 198
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'uncommit' => undef,
                                                                             'line' => 201,
                                                                             'number' => 1,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 202,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'AnyOp'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 202,
                                                                                                   'lookahead' => 1,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'anyOpIsolator'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ $item[1]; }',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 202
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ]
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'Expression',
                                                       'calls' => [
                                                                    'SignedTerm',
                                                                    'moreTerms',
                                                                    'addExpressionModifier',
                                                                    'AnyOp',
                                                                    'anyOpIsolator'
                                                                  ]
                                                     }, 'Parse::RecDescent::Rule' ),
                              'argPunct' => bless( {
                                                     'line' => 638,
                                                     'changed' => 0,
                                                     'vars' => '',
                                                     'name' => 'argPunct',
                                                     'prods' => [
                                                                  bless( {
                                                                           'number' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => undef,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'PUNCT',
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 639
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ]
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'number' => 1,
                                                                           'uncommit' => undef,
                                                                           'line' => 639,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef,
                                                                                                 'subrule' => 'MIDDLE',
                                                                                                 'matchrule' => 0,
                                                                                                 'line' => 639,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'error' => undef,
                                                                           'dircount' => 0
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'patcount' => 0,
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 639,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'VERTBAR',
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'number' => 2,
                                                                           'line' => 639,
                                                                           'uncommit' => undef,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'calls' => [
                                                                  'PUNCT',
                                                                  'MIDDLE',
                                                                  'VERTBAR'
                                                                ],
                                                     'impcount' => 0,
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'FLOATSUBSCRIPT' => bless( {
                                                           'opcount' => 0,
                                                           'prods' => [
                                                                        bless( {
                                                                                 'actcount' => 1,
                                                                                 'strcount' => 0,
                                                                                 'uncommit' => undef,
                                                                                 'line' => undef,
                                                                                 'number' => 0,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'ldelim' => '/',
                                                                                                       'rdelim' => '/',
                                                                                                       'pattern' => 'FLOATSUBSCRIPT:\\S*:\\d+',
                                                                                                       'description' => '/FLOATSUBSCRIPT:\\\\S*:\\\\d+/',
                                                                                                       'line' => 788,
                                                                                                       'mod' => '',
                                                                                                       'lookahead' => 0,
                                                                                                       'hashname' => '__PATTERN1__'
                                                                                                     }, 'Parse::RecDescent::Token' ),
                                                                                              bless( {
                                                                                                       'hashname' => '__ACTION1__',
                                                                                                       'code' => '{ Lookup($item[1]); }',
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 788
                                                                                                     }, 'Parse::RecDescent::Action' )
                                                                                            ],
                                                                                 'dircount' => 0,
                                                                                 'error' => undef,
                                                                                 'patcount' => 1
                                                                               }, 'Parse::RecDescent::Production' )
                                                                      ],
                                                           'name' => 'FLOATSUBSCRIPT',
                                                           'calls' => [],
                                                           'impcount' => 0,
                                                           'line' => 788,
                                                           'changed' => 0,
                                                           'vars' => ''
                                                         }, 'Parse::RecDescent::Rule' ),
                              'forbidArgs' => bless( {
                                                       'prods' => [
                                                                    bless( {
                                                                             'error' => undef,
                                                                             'dircount' => 0,
                                                                             'patcount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'subrule' => 'Argument',
                                                                                                   'matchrule' => 0,
                                                                                                   'line' => 507,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'repspec' => 's',
                                                                                                   'expected' => 'argPunct',
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => '_alternation_1_of_production_1_of_rule_forbidArgs',
                                                                                                   'line' => 507,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'max' => 100000000,
                                                                                                   'min' => 1
                                                                                                 }, 'Parse::RecDescent::Repetition' ),
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'balancedClose',
                                                                                                   'argcode' => '[$arg[1]]',
                                                                                                   'implicit' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 507
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 508,
                                                                                                   'lookahead' => 0,
                                                                                                   'code' => '{ MaybeFunction($arg[0]); undef; }',
                                                                                                   'hashname' => '__ACTION1__'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'number' => 0,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'strcount' => 0,
                                                                             'actcount' => 1,
                                                                             'line' => 510,
                                                                             'uncommit' => undef,
                                                                             'number' => 1,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'Term',
                                                                                                   'line' => 511,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'subrule' => 'balancedClose',
                                                                                                   'matchrule' => 0,
                                                                                                   'argcode' => '[$arg[1]]',
                                                                                                   'implicit' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 511
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 511,
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ MaybeFunction($arg[0]); undef; }'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'forbidArgs',
                                                       'calls' => [
                                                                    'Argument',
                                                                    '_alternation_1_of_production_1_of_rule_forbidArgs',
                                                                    'balancedClose',
                                                                    'Term'
                                                                  ],
                                                       'impcount' => 0,
                                                       'line' => 505,
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'opcount' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'LBRACE' => bless( {
                                                   'opcount' => 0,
                                                   'line' => 756,
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'prods' => [
                                                                bless( {
                                                                         'patcount' => 1,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'mod' => '',
                                                                                               'lookahead' => 0,
                                                                                               'description' => '/OPEN:\\\\\\{:\\\\d+/',
                                                                                               'line' => 756,
                                                                                               'pattern' => 'OPEN:\\{:\\d+',
                                                                                               'ldelim' => '/',
                                                                                               'rdelim' => '/'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 756
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'number' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => undef,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'name' => 'LBRACE',
                                                   'calls' => [],
                                                   'impcount' => 0
                                                 }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_8_of_rule_AnythingAny' => bless( {
                                                                                               'calls' => [
                                                                                                            'PUNCT',
                                                                                                            'AnyOp'
                                                                                                          ],
                                                                                               'prods' => [
                                                                                                            bless( {
                                                                                                                     'strcount' => 0,
                                                                                                                     'actcount' => 1,
                                                                                                                     'number' => 0,
                                                                                                                     'line' => undef,
                                                                                                                     'uncommit' => undef,
                                                                                                                     'items' => [
                                                                                                                                  bless( {
                                                                                                                                           'min' => 0,
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'max' => 1,
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'expected' => undef,
                                                                                                                                           'repspec' => '?',
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'subrule' => 'PUNCT'
                                                                                                                                         }, 'Parse::RecDescent::Repetition' ),
                                                                                                                                  bless( {
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'implicit' => undef,
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'subrule' => 'AnyOp',
                                                                                                                                           'matchrule' => 0
                                                                                                                                         }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                  bless( {
                                                                                                                                           'code' => '{[$item[1]->[0]||InvisibleComma(), $item[2]]}',
                                                                                                                                           'hashname' => '__ACTION1__',
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0
                                                                                                                                         }, 'Parse::RecDescent::Action' )
                                                                                                                                ],
                                                                                                                     'patcount' => 0,
                                                                                                                     'dircount' => 0,
                                                                                                                     'error' => undef
                                                                                                                   }, 'Parse::RecDescent::Production' )
                                                                                                          ],
                                                                                               'name' => '_alternation_1_of_production_8_of_rule_AnythingAny',
                                                                                               'impcount' => 0,
                                                                                               'line' => 791,
                                                                                               'vars' => '',
                                                                                               'changed' => 0,
                                                                                               'opcount' => 0
                                                                                             }, 'Parse::RecDescent::Rule' ),
                              'RANGLE' => bless( {
                                                   'opcount' => 0,
                                                   'impcount' => 0,
                                                   'prods' => [
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'line' => 751,
                                                                                               'description' => '/RELOP:greater-than:\\\\d+/',
                                                                                               'pattern' => 'RELOP:greater-than:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/',
                                                                                               'hashname' => '__PATTERN1__'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'line' => 751,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 1,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => undef,
                                                                         'number' => 0
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'uncommit' => undef,
                                                                         'line' => 752,
                                                                         'number' => 1,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 1,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'line' => 752,
                                                                                               'description' => '/CLOSE:rangle:\\\\d+/',
                                                                                               'mod' => '',
                                                                                               'lookahead' => 0,
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/',
                                                                                               'pattern' => 'CLOSE:rangle:\\d+'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'line' => 752,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'name' => 'RANGLE',
                                                   'calls' => [],
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 751
                                                 }, 'Parse::RecDescent::Rule' ),
                              'SCRIPTOPEN' => bless( {
                                                       'opcount' => 0,
                                                       'impcount' => 0,
                                                       'name' => 'SCRIPTOPEN',
                                                       'prods' => [
                                                                    bless( {
                                                                             'patcount' => 1,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'hashname' => '__PATTERN1__',
                                                                                                   'lookahead' => 0,
                                                                                                   'mod' => '',
                                                                                                   'line' => 773,
                                                                                                   'description' => '/OPEN:\\\\\\{:\\\\d+/',
                                                                                                   'pattern' => 'OPEN:\\{:\\d+',
                                                                                                   'ldelim' => '/',
                                                                                                   'rdelim' => '/'
                                                                                                 }, 'Parse::RecDescent::Token' ),
                                                                                          bless( {
                                                                                                   'line' => 773,
                                                                                                   'lookahead' => 0,
                                                                                                   'code' => '{ Lookup($item[1]); }',
                                                                                                   'hashname' => '__ACTION1__'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'number' => 0,
                                                                             'line' => undef,
                                                                             'uncommit' => undef,
                                                                             'strcount' => 0,
                                                                             'actcount' => 1
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'calls' => [],
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'line' => 773
                                                     }, 'Parse::RecDescent::Rule' ),
                              'Term' => bless( {
                                                 'opcount' => 0,
                                                 'impcount' => 0,
                                                 'calls' => [
                                                              'Factor',
                                                              'moreFactors'
                                                            ],
                                                 'prods' => [
                                                              bless( {
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'argcode' => undef,
                                                                                             'implicit' => undef,
                                                                                             'subrule' => 'Factor',
                                                                                             'matchrule' => 0,
                                                                                             'line' => 246,
                                                                                             'lookahead' => 0
                                                                                           }, 'Parse::RecDescent::Subrule' ),
                                                                                    bless( {
                                                                                             'lookahead' => 0,
                                                                                             'line' => 246,
                                                                                             'matchrule' => 0,
                                                                                             'subrule' => 'moreFactors',
                                                                                             'argcode' => '[$item[1]]',
                                                                                             'implicit' => undef
                                                                                           }, 'Parse::RecDescent::Subrule' )
                                                                                  ],
                                                                       'patcount' => 0,
                                                                       'dircount' => 0,
                                                                       'error' => undef,
                                                                       'actcount' => 0,
                                                                       'strcount' => 0,
                                                                       'number' => 0,
                                                                       'uncommit' => undef,
                                                                       'line' => undef
                                                                     }, 'Parse::RecDescent::Production' )
                                                            ],
                                                 'name' => 'Term',
                                                 'vars' => '',
                                                 'changed' => 0,
                                                 'line' => 246
                                               }, 'Parse::RecDescent::Rule' ),
                              'Factor' => bless( {
                                                   'opcount' => 0,
                                                   'impcount' => 0,
                                                   'calls' => [
                                                                'OPEN',
                                                                'ARRAY',
                                                                'CLOSE',
                                                                'addScripts',
                                                                'LBRACE',
                                                                'RBRACE',
                                                                'preScripted',
                                                                'addArgs',
                                                                'addOpFunArgs',
                                                                'addTrigFunArgs',
                                                                'maybeArgs',
                                                                'doubtArgs',
                                                                'NUMBER',
                                                                'SCRIPTOPEN',
                                                                'scriptFactorOpen',
                                                                'factorOpen',
                                                                'addIntOpArgs',
                                                                'addOpArgs',
                                                                'SINGLEVERTBAR',
                                                                'absExpression',
                                                                'VERTBAR',
                                                                'MIDBAR',
                                                                'ketExpression',
                                                                'RANGLE',
                                                                'LANGLE',
                                                                'maybeBra',
                                                                'OPERATOR',
                                                                'nestOperators'
                                                              ],
                                                   'name' => 'Factor',
                                                   'prods' => [
                                                                bless( {
                                                                         'uncommit' => undef,
                                                                         'line' => undef,
                                                                         'number' => 0,
                                                                         'actcount' => 0,
                                                                         'strcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'OPEN',
                                                                                               'line' => 267,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 268,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'ARRAY',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 268,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'CLOSE',
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 268,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[Fence($item[1],$item[2],$item[3])]',
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addScripts'
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'subrule' => 'LBRACE',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 271,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'subrule' => 'ARRAY',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 271,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ InterpretDelimited(New(\'cases\'),$item[1],$item[2],Absent()); }',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 271
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'number' => 1,
                                                                         'line' => 270,
                                                                         'uncommit' => undef
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 272,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'ARRAY'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 272,
                                                                                               'subrule' => 'RBRACE',
                                                                                               'matchrule' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ InterpretDelimited(New(\'cases\'),Absent(),$item[1],$item[2]); }',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 272
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'number' => 2,
                                                                         'line' => 272,
                                                                         'uncommit' => undef
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 273,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'preScripted',
                                                                                               'argcode' => '[\'FUNCTION\']',
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 273,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addArgs'
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'actcount' => 0,
                                                                         'strcount' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => 273,
                                                                         'number' => 3
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'number' => 4,
                                                                         'uncommit' => undef,
                                                                         'line' => 274,
                                                                         'actcount' => 0,
                                                                         'strcount' => 0,
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 274,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[\'OPFUNCTION\']',
                                                                                               'subrule' => 'preScripted',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 274,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addOpFunArgs'
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'line' => 275,
                                                                         'uncommit' => undef,
                                                                         'number' => 5,
                                                                         'strcount' => 0,
                                                                         'actcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'argcode' => '[\'TRIGFUNCTION\']',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'preScripted',
                                                                                               'line' => 275,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'subrule' => 'addTrigFunArgs',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 275
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[\'ATOM_OR_ID\']',
                                                                                               'subrule' => 'preScripted',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 276,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 276,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'maybeArgs',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'strcount' => 0,
                                                                         'actcount' => 0,
                                                                         'line' => 276,
                                                                         'uncommit' => undef,
                                                                         'number' => 6
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'subrule' => 'preScripted',
                                                                                               'matchrule' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[\'UNKNOWN\']',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 277
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'doubtArgs',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 277,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'strcount' => 0,
                                                                         'actcount' => 0,
                                                                         'number' => 7,
                                                                         'line' => 277,
                                                                         'uncommit' => undef
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'strcount' => 0,
                                                                         'actcount' => 0,
                                                                         'line' => 278,
                                                                         'uncommit' => undef,
                                                                         'number' => 8,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 278,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'NUMBER',
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'subrule' => 'addScripts',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 278
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'patcount' => 0
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 279,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'subrule' => 'SCRIPTOPEN',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 279,
                                                                                               'subrule' => 'scriptFactorOpen',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'actcount' => 0,
                                                                         'strcount' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => 279,
                                                                         'number' => 9
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'strcount' => 0,
                                                                         'actcount' => 0,
                                                                         'line' => 280,
                                                                         'uncommit' => undef,
                                                                         'number' => 10,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 280,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'OPEN'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'subrule' => 'factorOpen',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 280,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'strcount' => 0,
                                                                         'actcount' => 0,
                                                                         'number' => 11,
                                                                         'line' => 281,
                                                                         'uncommit' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'argcode' => '[\'INTOP\']',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'preScripted',
                                                                                               'line' => 282,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addIntOpArgs',
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 282
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'argcode' => '[\'bigop\']',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'preScripted',
                                                                                               'line' => 283,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addOpArgs',
                                                                                               'line' => 283,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'actcount' => 0,
                                                                         'strcount' => 0,
                                                                         'number' => 12,
                                                                         'uncommit' => undef,
                                                                         'line' => 283
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 284,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ ($forbidVertBar ? undef : 1); }'
                                                                                             }, 'Parse::RecDescent::Action' ),
                                                                                      bless( {
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'SINGLEVERTBAR',
                                                                                               'line' => 285,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'subrule' => 'SINGLEVERTBAR',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 285
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 285,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'absExpression'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'subrule' => 'SINGLEVERTBAR',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 285,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 285,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'SINGLEVERTBAR',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 285,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[Fence(CatSymbols($item[2],$item[3],undef,\'||\',role=>\'OPEN\'),
                $item[4],
                CatSymbols($item[5],$item[6],undef,\'||\',role=>\'CLOSE\'))]',
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addScripts'
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'line' => 284,
                                                                         'uncommit' => undef,
                                                                         'number' => 13
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'number' => 14,
                                                                         'uncommit' => undef,
                                                                         'line' => 289,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 289,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ ($forbidVertBar ? undef : 1); }'
                                                                                             }, 'Parse::RecDescent::Action' ),
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'VERTBAR',
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 290
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 290,
                                                                                               'subrule' => 'absExpression',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 290,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'VERTBAR'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 290,
                                                                                               'subrule' => 'addScripts',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => '[Fence($item[2],$item[3],$item[4])]',
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'number' => 15,
                                                                         'uncommit' => undef,
                                                                         'line' => 292,
                                                                         'actcount' => 2,
                                                                         'strcount' => 0,
                                                                         'patcount' => 0,
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'line' => 292,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ ($forbidVertBar ? undef : IsNotationAllowed(\'QM\')); }',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::Action' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 293,
                                                                                               'subrule' => 'MIDBAR',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 293,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'ketExpression',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'RANGLE',
                                                                                               'line' => 293,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 293,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ SawNotation(\'QM\'); }',
                                                                                               'hashname' => '__ACTION2__'
                                                                                             }, 'Parse::RecDescent::Action' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 293,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addScripts',
                                                                                               'argcode' => '[InterpretDelimited(New(\'ket\'),
                    Annotate($item[2],role=>\'OPEN\'),$item[3],Annotate($item[4],role=>\'CLOSE\'))]',
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ IsNotationAllowed(\'QM\'); }',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 296
                                                                                             }, 'Parse::RecDescent::Action' ),
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'LANGLE',
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 297
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 297,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'ketExpression'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'MIDBAR',
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 297
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 297,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'maybeBra',
                                                                                               'argcode' => '[$item[2],$item[3],$item[4]]',
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'uncommit' => undef,
                                                                         'line' => 295,
                                                                         'number' => 16,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'code' => '{ IsNotationAllowed(\'QM\'); }',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'line' => 298,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Action' ),
                                                                                      bless( {
                                                                                               'line' => 299,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'LANGLE',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 299,
                                                                                               'subrule' => 'absExpression',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 299,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'RANGLE'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 300,
                                                                                               'lookahead' => 0,
                                                                                               'implicit' => undef,
                                                                                               'argcode' => '[Fence(Annotate($item[2],role=>\'OPEN\'),
                          $item[3],
                          Annotate($item[4],role=>\'CLOSE\'))]',
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'addScripts'
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'patcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'number' => 17,
                                                                         'uncommit' => undef,
                                                                         'line' => 298
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'argcode' => undef,
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'OPERATOR',
                                                                                               'matchrule' => 0,
                                                                                               'line' => 303,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 303,
                                                                                               'subrule' => 'addScripts',
                                                                                               'matchrule' => 0,
                                                                                               'argcode' => '[$item[1]]',
                                                                                               'implicit' => undef
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 303,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => '[$item[2]]',
                                                                                               'implicit' => undef,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'nestOperators'
                                                                                             }, 'Parse::RecDescent::Subrule' ),
                                                                                      bless( {
                                                                                               'line' => 304,
                                                                                               'lookahead' => 0,
                                                                                               'argcode' => '[$item[3]]',
                                                                                               'implicit' => undef,
                                                                                               'subrule' => 'addOpFunArgs',
                                                                                               'matchrule' => 0
                                                                                             }, 'Parse::RecDescent::Subrule' )
                                                                                    ],
                                                                         'uncommit' => undef,
                                                                         'line' => 303,
                                                                         'number' => 18,
                                                                         'actcount' => 0,
                                                                         'strcount' => 0
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'vars' => '',
                                                   'changed' => 0,
                                                   'line' => 264
                                                 }, 'Parse::RecDescent::Rule' ),
                              'TRIGFUNCTION' => bless( {
                                                         'line' => 768,
                                                         'changed' => 0,
                                                         'vars' => '',
                                                         'name' => 'TRIGFUNCTION',
                                                         'prods' => [
                                                                      bless( {
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'number' => 0,
                                                                               'line' => undef,
                                                                               'uncommit' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'pattern' => 'TRIGFUNCTION:\\S*:\\d+',
                                                                                                     'ldelim' => '/',
                                                                                                     'rdelim' => '/',
                                                                                                     'lookahead' => 0,
                                                                                                     'mod' => '',
                                                                                                     'line' => 768,
                                                                                                     'description' => '/TRIGFUNCTION:\\\\S*:\\\\d+/',
                                                                                                     'hashname' => '__PATTERN1__'
                                                                                                   }, 'Parse::RecDescent::Token' ),
                                                                                            bless( {
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ Lookup($item[1]); }',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 768
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'patcount' => 1,
                                                                               'dircount' => 0,
                                                                               'error' => undef
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'calls' => [],
                                                         'impcount' => 0,
                                                         'opcount' => 0
                                                       }, 'Parse::RecDescent::Rule' ),
                              'extendFormula' => bless( {
                                                          'opcount' => 0,
                                                          'line' => 133,
                                                          'changed' => 0,
                                                          'vars' => '',
                                                          'name' => 'extendFormula',
                                                          'prods' => [
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'pattern' => '^\\Z',
                                                                                                      'rdelim' => '/',
                                                                                                      'ldelim' => '/',
                                                                                                      'lookahead' => 0,
                                                                                                      'mod' => '',
                                                                                                      'line' => 135,
                                                                                                      'description' => '/^\\\\Z/',
                                                                                                      'hashname' => '__PATTERN1__'
                                                                                                    }, 'Parse::RecDescent::Token' ),
                                                                                             bless( {
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ $arg[0];}',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 135
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 1,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'number' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'number' => 1,
                                                                                'uncommit' => undef,
                                                                                'line' => 135,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0,
                                                                                'patcount' => 0,
                                                                                'error' => undef,
                                                                                'dircount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'repspec' => 's',
                                                                                                      'expected' => undef,
                                                                                                      'subrule' => 'punctExpr',
                                                                                                      'matchrule' => 0,
                                                                                                      'line' => 136,
                                                                                                      'lookahead' => 0,
                                                                                                      'argcode' => undef,
                                                                                                      'max' => 100000000,
                                                                                                      'min' => 1
                                                                                                    }, 'Parse::RecDescent::Repetition' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 136,
                                                                                                      'subrule' => 'maybeRHS',
                                                                                                      'matchrule' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$arg[0],map(@$_,@{$item[1]})]'
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 137,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'subrule' => 'relop',
                                                                                                      'matchrule' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'Expression',
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 137
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'line' => 137,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$arg[0],$item[1],$item[2]]',
                                                                                                      'subrule' => 'moreRHS',
                                                                                                      'matchrule' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'number' => 2,
                                                                                'line' => 137,
                                                                                'uncommit' => undef,
                                                                                'strcount' => 0,
                                                                                'actcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'error' => undef,
                                                                                'dircount' => 0,
                                                                                'patcount' => 1,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 138,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'relop',
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'rdelim' => '/',
                                                                                                      'ldelim' => '/',
                                                                                                      'pattern' => '^\\Z',
                                                                                                      'line' => 138,
                                                                                                      'description' => '/^\\\\Z/',
                                                                                                      'mod' => '',
                                                                                                      'lookahead' => 0,
                                                                                                      'hashname' => '__PATTERN1__'
                                                                                                    }, 'Parse::RecDescent::Token' ),
                                                                                             bless( {
                                                                                                      'line' => 138,
                                                                                                      'lookahead' => 0,
                                                                                                      'code' => '{ NewFormula($arg[0],$item[1], Absent()); }',
                                                                                                      'hashname' => '__ACTION1__'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'line' => 138,
                                                                                'uncommit' => undef,
                                                                                'number' => 3,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'line' => 139,
                                                                                'uncommit' => undef,
                                                                                'number' => 4,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 139,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ $arg[0]; }'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'calls' => [
                                                                       'punctExpr',
                                                                       'maybeRHS',
                                                                       'relop',
                                                                       'Expression',
                                                                       'moreRHS'
                                                                     ],
                                                          'impcount' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'moreOpArgFactors' => bless( {
                                                             'impcount' => 0,
                                                             'name' => 'moreOpArgFactors',
                                                             'prods' => [
                                                                          bless( {
                                                                                   'strcount' => 0,
                                                                                   'actcount' => 1,
                                                                                   'line' => undef,
                                                                                   'uncommit' => undef,
                                                                                   'number' => 0,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'pattern' => '^\\Z',
                                                                                                         'rdelim' => '/',
                                                                                                         'ldelim' => '/',
                                                                                                         'mod' => '',
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 598,
                                                                                                         'description' => '/^\\\\Z/',
                                                                                                         'hashname' => '__PATTERN1__'
                                                                                                       }, 'Parse::RecDescent::Token' ),
                                                                                                bless( {
                                                                                                         'code' => '{ $arg[0];}',
                                                                                                         'hashname' => '__ACTION1__',
                                                                                                         'line' => 598,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ],
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 1
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'number' => 1,
                                                                                   'uncommit' => undef,
                                                                                   'line' => 598,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 599,
                                                                                                         'subrule' => 'MulOp',
                                                                                                         'matchrule' => 0,
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'subrule' => 'Factor',
                                                                                                         'matchrule' => 0,
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 599
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => '[ApplyNary($item[1],$arg[0],$item[2])]',
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'moreOpArgFactors',
                                                                                                         'line' => 599,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ],
                                                                                   'patcount' => 0,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'actcount' => 0,
                                                                                   'strcount' => 0,
                                                                                   'number' => 2,
                                                                                   'uncommit' => undef,
                                                                                   'line' => 600,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 600,
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'Factor',
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => undef
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'line' => 600,
                                                                                                         'lookahead' => 0,
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => '[ApplyNary(InvisibleTimes(),$arg[0],$item[1])]',
                                                                                                         'subrule' => 'moreOpArgFactors',
                                                                                                         'matchrule' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' )
                                                                                              ],
                                                                                   'patcount' => 0,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 0,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'line' => 601,
                                                                                                         'lookahead' => 0,
                                                                                                         'code' => '{ $arg[0]; }',
                                                                                                         'hashname' => '__ACTION1__'
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ],
                                                                                   'uncommit' => undef,
                                                                                   'line' => 601,
                                                                                   'number' => 3,
                                                                                   'actcount' => 1,
                                                                                   'strcount' => 0
                                                                                 }, 'Parse::RecDescent::Production' )
                                                                        ],
                                                             'calls' => [
                                                                          'MulOp',
                                                                          'Factor',
                                                                          'moreOpArgFactors'
                                                                        ],
                                                             'changed' => 0,
                                                             'vars' => '',
                                                             'line' => 596,
                                                             'opcount' => 0
                                                           }, 'Parse::RecDescent::Rule' ),
                              'addArgs' => bless( {
                                                    'opcount' => 0,
                                                    'line' => 525,
                                                    'changed' => 0,
                                                    'vars' => '',
                                                    'prods' => [
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'hashname' => '__PATTERN1__',
                                                                                                'line' => 527,
                                                                                                'description' => '/^\\\\Z/',
                                                                                                'mod' => '',
                                                                                                'lookahead' => 0,
                                                                                                'rdelim' => '/',
                                                                                                'ldelim' => '/',
                                                                                                'pattern' => '^\\Z'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ $arg[0];}',
                                                                                                'lookahead' => 0,
                                                                                                'line' => 527
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 1,
                                                                          'strcount' => 0,
                                                                          'actcount' => 1,
                                                                          'line' => undef,
                                                                          'uncommit' => undef,
                                                                          'number' => 0
                                                                        }, 'Parse::RecDescent::Production' ),
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'addEasyArgs',
                                                                                                'implicit' => undef,
                                                                                                'argcode' => '[$arg[0]]',
                                                                                                'lookahead' => 0,
                                                                                                'line' => 528
                                                                                              }, 'Parse::RecDescent::Subrule' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 0,
                                                                          'actcount' => 0,
                                                                          'strcount' => 0,
                                                                          'uncommit' => undef,
                                                                          'line' => 527,
                                                                          'number' => 1
                                                                        }, 'Parse::RecDescent::Production' ),
                                                                 bless( {
                                                                          'error' => undef,
                                                                          'dircount' => 0,
                                                                          'patcount' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'implicit' => undef,
                                                                                                'argcode' => undef,
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'APPLYOP',
                                                                                                'line' => 530,
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::Subrule' ),
                                                                                       bless( {
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'barearg',
                                                                                                'implicit' => undef,
                                                                                                'argcode' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'line' => 530
                                                                                              }, 'Parse::RecDescent::Subrule' ),
                                                                                       bless( {
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ Apply($arg[0],$item[2]);}',
                                                                                                'lookahead' => 0,
                                                                                                'line' => 530
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'uncommit' => undef,
                                                                          'line' => 529,
                                                                          'number' => 2,
                                                                          'actcount' => 1,
                                                                          'strcount' => 0
                                                                        }, 'Parse::RecDescent::Production' ),
                                                                 bless( {
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 531,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ $arg[0]; }'
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'line' => 531,
                                                                          'uncommit' => undef,
                                                                          'number' => 3,
                                                                          'strcount' => 0,
                                                                          'actcount' => 1
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'name' => 'addArgs',
                                                    'calls' => [
                                                                 'addEasyArgs',
                                                                 'APPLYOP',
                                                                 'barearg'
                                                               ],
                                                    'impcount' => 0
                                                  }, 'Parse::RecDescent::Rule' ),
                              'maybeRHS' => bless( {
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'line' => 143,
                                                     'impcount' => 0,
                                                     'calls' => [
                                                                  'relopExpr'
                                                                ],
                                                     'name' => 'maybeRHS',
                                                     'prods' => [
                                                                  bless( {
                                                                           'strcount' => 0,
                                                                           'actcount' => 1,
                                                                           'line' => undef,
                                                                           'uncommit' => undef,
                                                                           'number' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'pattern' => '^\\Z',
                                                                                                 'rdelim' => '/',
                                                                                                 'ldelim' => '/',
                                                                                                 'mod' => '',
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 145,
                                                                                                 'description' => '/^\\\\Z/',
                                                                                                 'hashname' => '__PATTERN1__'
                                                                                               }, 'Parse::RecDescent::Token' ),
                                                                                        bless( {
                                                                                                 'code' => '{ NewList(@arg); }',
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'line' => 145,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'patcount' => 1
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'min' => 1,
                                                                                                 'max' => 100000000,
                                                                                                 'argcode' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 146,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'relopExpr',
                                                                                                 'repspec' => 's',
                                                                                                 'expected' => undef
                                                                                               }, 'Parse::RecDescent::Repetition' ),
                                                                                        bless( {
                                                                                                 'code' => '{ NewFormula(NewList(@arg),map(@$_,@{$item[1]})); }',
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'line' => 146,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 0,
                                                                           'actcount' => 1,
                                                                           'strcount' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => 146,
                                                                           'number' => 1
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 147,
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'code' => '{ NewList(@arg); }'
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'strcount' => 0,
                                                                           'actcount' => 1,
                                                                           'number' => 2,
                                                                           'line' => 147,
                                                                           'uncommit' => undef
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'MULOP' => bless( {
                                                  'line' => 763,
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'prods' => [
                                                               bless( {
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'ldelim' => '/',
                                                                                              'rdelim' => '/',
                                                                                              'pattern' => 'MULOP:\\S*:\\d+',
                                                                                              'description' => '/MULOP:\\\\S*:\\\\d+/',
                                                                                              'line' => 763,
                                                                                              'lookahead' => 0,
                                                                                              'mod' => ''
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'line' => 763,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'dircount' => 0,
                                                                        'error' => undef
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'MULOP',
                                                  'calls' => [],
                                                  'impcount' => 0,
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'POSTFIX' => bless( {
                                                    'opcount' => 0,
                                                    'impcount' => 0,
                                                    'name' => 'POSTFIX',
                                                    'prods' => [
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'pattern' => 'POSTFIX:\\S*:\\d+',
                                                                                                'ldelim' => '/',
                                                                                                'rdelim' => '/',
                                                                                                'mod' => '',
                                                                                                'lookahead' => 0,
                                                                                                'description' => '/POSTFIX:\\\\S*:\\\\d+/',
                                                                                                'line' => 765,
                                                                                                'hashname' => '__PATTERN1__'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'code' => '{ Lookup($item[1]); }',
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'line' => 765,
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 1,
                                                                          'actcount' => 1,
                                                                          'strcount' => 0,
                                                                          'uncommit' => undef,
                                                                          'line' => undef,
                                                                          'number' => 0
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'calls' => [],
                                                    'changed' => 0,
                                                    'vars' => '',
                                                    'line' => 765
                                                  }, 'Parse::RecDescent::Rule' ),
                              'aSuperscript' => bless( {
                                                         'opcount' => 0,
                                                         'impcount' => 0,
                                                         'calls' => [
                                                                      'supops',
                                                                      'Formulae',
                                                                      'AnyOp',
                                                                      'Expression'
                                                                    ],
                                                         'name' => 'aSuperscript',
                                                         'prods' => [
                                                                      bless( {
                                                                               'strcount' => 0,
                                                                               'actcount' => 0,
                                                                               'number' => 0,
                                                                               'line' => undef,
                                                                               'uncommit' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'supops',
                                                                                                     'line' => 100,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'strcount' => 0,
                                                                               'actcount' => 0,
                                                                               'line' => 101,
                                                                               'uncommit' => undef,
                                                                               'number' => 1,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'line' => 101,
                                                                                                     'lookahead' => 0,
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'Formulae'
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'actcount' => 1,
                                                                               'strcount' => 0,
                                                                               'uncommit' => undef,
                                                                               'line' => 102,
                                                                               'number' => 2,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 102,
                                                                                                     'subrule' => 'AnyOp',
                                                                                                     'matchrule' => 0,
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 102,
                                                                                                     'subrule' => 'Expression',
                                                                                                     'matchrule' => 0,
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'line' => 102,
                                                                                                     'lookahead' => 0,
                                                                                                     'code' => '{ Apply($item[1],Absent(),$item[2]);}',
                                                                                                     'hashname' => '__ACTION1__'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'subrule' => 'AnyOp',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 103,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'actcount' => 0,
                                                                               'strcount' => 0,
                                                                               'number' => 3,
                                                                               'uncommit' => undef,
                                                                               'line' => 103
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'vars' => '',
                                                         'changed' => 0,
                                                         'line' => 99
                                                       }, 'Parse::RecDescent::Rule' ),
                              'SUMOP' => bless( {
                                                  'opcount' => 0,
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'line' => 779,
                                                  'impcount' => 0,
                                                  'name' => 'SUMOP',
                                                  'prods' => [
                                                               bless( {
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'description' => '/SUMOP:\\\\S*:\\\\d+/',
                                                                                              'line' => 779,
                                                                                              'pattern' => 'SUMOP:\\S*:\\d+',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 779,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'patcount' => 1
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'calls' => []
                                                }, 'Parse::RecDescent::Rule' ),
                              'COMPOSEOP' => bless( {
                                                      'prods' => [
                                                                   bless( {
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 1,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__PATTERN1__',
                                                                                                  'lookahead' => 0,
                                                                                                  'mod' => '',
                                                                                                  'description' => '/COMPOSEOP:\\\\S*:\\\\d+/',
                                                                                                  'line' => 770,
                                                                                                  'pattern' => 'COMPOSEOP:\\S*:\\d+',
                                                                                                  'ldelim' => '/',
                                                                                                  'rdelim' => '/'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ Lookup($item[1]); }',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 770
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'uncommit' => undef,
                                                                            'line' => undef,
                                                                            'number' => 0,
                                                                            'actcount' => 1,
                                                                            'strcount' => 0
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'name' => 'COMPOSEOP',
                                                      'calls' => [],
                                                      'impcount' => 0,
                                                      'line' => 770,
                                                      'changed' => 0,
                                                      'vars' => '',
                                                      'opcount' => 0
                                                    }, 'Parse::RecDescent::Rule' ),
                              'LANGLE' => bless( {
                                                   'opcount' => 0,
                                                   'impcount' => 0,
                                                   'prods' => [
                                                                bless( {
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => undef,
                                                                         'number' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'description' => '/RELOP:less-than:\\\\d+/',
                                                                                               'line' => 749,
                                                                                               'pattern' => 'RELOP:less-than:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'line' => 749,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 1
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'line' => 750,
                                                                                               'description' => '/OPEN:langle:\\\\d+/',
                                                                                               'pattern' => 'OPEN:langle:\\d+',
                                                                                               'ldelim' => '/',
                                                                                               'rdelim' => '/'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 750,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ Lookup($item[1]); }'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'patcount' => 1,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => 750,
                                                                         'number' => 1
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'name' => 'LANGLE',
                                                   'calls' => [],
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 749
                                                 }, 'Parse::RecDescent::Rule' ),
                              'NUMBER' => bless( {
                                                   'opcount' => 0,
                                                   'impcount' => 0,
                                                   'name' => 'NUMBER',
                                                   'prods' => [
                                                                bless( {
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'line' => undef,
                                                                         'uncommit' => undef,
                                                                         'number' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'pattern' => 'NUMBER:\\S*:\\d+',
                                                                                               'ldelim' => '/',
                                                                                               'rdelim' => '/',
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'line' => 745,
                                                                                               'description' => '/NUMBER:\\\\S*:\\\\d+/'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'line' => 745,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'patcount' => 1
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'calls' => [],
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 745
                                                 }, 'Parse::RecDescent::Rule' ),
                              'punctExpr' => bless( {
                                                      'opcount' => 0,
                                                      'vars' => '',
                                                      'changed' => 0,
                                                      'line' => 172,
                                                      'impcount' => 0,
                                                      'calls' => [
                                                                   'PUNCT',
                                                                   'Expression'
                                                                 ],
                                                      'prods' => [
                                                                   bless( {
                                                                            'patcount' => 0,
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 175,
                                                                                                  'subrule' => 'PUNCT',
                                                                                                  'matchrule' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'Expression',
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 175
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 175,
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ [$item[1],$item[2]]; }'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'number' => 0,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'name' => 'punctExpr'
                                                    }, 'Parse::RecDescent::Rule' ),
                              'OPEN' => bless( {
                                                 'vars' => '',
                                                 'changed' => 0,
                                                 'line' => 772,
                                                 'impcount' => 0,
                                                 'calls' => [],
                                                 'name' => 'OPEN',
                                                 'prods' => [
                                                              bless( {
                                                                       'items' => [
                                                                                    bless( {
                                                                                             'line' => 772,
                                                                                             'description' => '/OPEN:\\\\S*:\\\\d+/',
                                                                                             'lookahead' => 0,
                                                                                             'mod' => '',
                                                                                             'ldelim' => '/',
                                                                                             'rdelim' => '/',
                                                                                             'pattern' => 'OPEN:\\S*:\\d+',
                                                                                             'hashname' => '__PATTERN1__'
                                                                                           }, 'Parse::RecDescent::Token' ),
                                                                                    bless( {
                                                                                             'lookahead' => 0,
                                                                                             'line' => 772,
                                                                                             'hashname' => '__ACTION1__',
                                                                                             'code' => '{ Lookup($item[1]); }'
                                                                                           }, 'Parse::RecDescent::Action' )
                                                                                  ],
                                                                       'patcount' => 1,
                                                                       'error' => undef,
                                                                       'dircount' => 0,
                                                                       'actcount' => 1,
                                                                       'strcount' => 0,
                                                                       'number' => 0,
                                                                       'uncommit' => undef,
                                                                       'line' => undef
                                                                     }, 'Parse::RecDescent::Production' )
                                                            ],
                                                 'opcount' => 0
                                               }, 'Parse::RecDescent::Rule' ),
                              'ADDOP' => bless( {
                                                  'opcount' => 0,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'line' => 762,
                                                  'impcount' => 0,
                                                  'calls' => [],
                                                  'prods' => [
                                                               bless( {
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 1,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'line' => 762,
                                                                                              'description' => '/ADDOP:\\\\S*:\\\\d+/',
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => 'ADDOP:\\S*:\\d+'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 762,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'ADDOP'
                                                }, 'Parse::RecDescent::Rule' ),
                              'aTrigBarearg' => bless( {
                                                         'opcount' => 0,
                                                         'changed' => 0,
                                                         'vars' => '',
                                                         'line' => 331,
                                                         'impcount' => 0,
                                                         'prods' => [
                                                                      bless( {
                                                                               'line' => undef,
                                                                               'uncommit' => undef,
                                                                               'number' => 0,
                                                                               'strcount' => 0,
                                                                               'actcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'argcode' => '[\'FUNCTION\']',
                                                                                                     'implicit' => undef,
                                                                                                     'subrule' => 'preScripted',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 332,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => '[$item[1]]',
                                                                                                     'subrule' => 'addArgs',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 332,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 333,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'preScripted',
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => '[\'OPFUNCTION\']'
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'argcode' => '[$item[1]]',
                                                                                                     'implicit' => undef,
                                                                                                     'subrule' => 'addOpFunArgs',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 333,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'strcount' => 0,
                                                                               'actcount' => 0,
                                                                               'number' => 1,
                                                                               'line' => 333,
                                                                               'uncommit' => undef
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'line' => 334,
                                                                               'uncommit' => undef,
                                                                               'number' => 2,
                                                                               'strcount' => 0,
                                                                               'actcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'subrule' => 'preScripted',
                                                                                                     'matchrule' => 0,
                                                                                                     'implicit' => undef,
                                                                                                     'argcode' => '[\'ATOM_OR_ID\']',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 334
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 334,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'maybeArgs',
                                                                                                     'argcode' => '[$item[1]]',
                                                                                                     'implicit' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 335,
                                                                                                     'subrule' => 'preScripted',
                                                                                                     'matchrule' => 0,
                                                                                                     'argcode' => '[\'UNKNOWN\']',
                                                                                                     'implicit' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 335,
                                                                                                     'subrule' => 'doubtArgs',
                                                                                                     'matchrule' => 0,
                                                                                                     'argcode' => '[$item[1]]',
                                                                                                     'implicit' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'uncommit' => undef,
                                                                               'line' => 335,
                                                                               'number' => 3,
                                                                               'actcount' => 0,
                                                                               'strcount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 336,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'NUMBER',
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'argcode' => '[$item[1]]',
                                                                                                     'implicit' => undef,
                                                                                                     'subrule' => 'addScripts',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 336,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0,
                                                                               'strcount' => 0,
                                                                               'actcount' => 0,
                                                                               'line' => 336,
                                                                               'uncommit' => undef,
                                                                               'number' => 4
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'actcount' => 0,
                                                                               'strcount' => 0,
                                                                               'uncommit' => undef,
                                                                               'line' => 337,
                                                                               'number' => 5,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'line' => 337,
                                                                                                     'lookahead' => 0,
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'subrule' => 'VERTBAR',
                                                                                                     'matchrule' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'Expression',
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 337
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 337,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'VERTBAR',
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'line' => 337,
                                                                                                     'lookahead' => 0,
                                                                                                     'argcode' => '[Fence($item[1],$item[2],$item[3])]',
                                                                                                     'implicit' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'addScripts'
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ],
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'name' => 'aTrigBarearg',
                                                         'calls' => [
                                                                      'preScripted',
                                                                      'addArgs',
                                                                      'addOpFunArgs',
                                                                      'maybeArgs',
                                                                      'doubtArgs',
                                                                      'NUMBER',
                                                                      'addScripts',
                                                                      'VERTBAR',
                                                                      'Expression'
                                                                    ]
                                                       }, 'Parse::RecDescent::Rule' ),
                              'OPFUNCTION' => bless( {
                                                       'prods' => [
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'ldelim' => '/',
                                                                                                   'rdelim' => '/',
                                                                                                   'pattern' => 'OPFUNCTION:\\S*:\\d+',
                                                                                                   'line' => 767,
                                                                                                   'description' => '/OPFUNCTION:\\\\S*:\\\\d+/',
                                                                                                   'mod' => '',
                                                                                                   'lookahead' => 0,
                                                                                                   'hashname' => '__PATTERN1__'
                                                                                                 }, 'Parse::RecDescent::Token' ),
                                                                                          bless( {
                                                                                                   'line' => 767,
                                                                                                   'lookahead' => 0,
                                                                                                   'code' => '{ Lookup($item[1]); }',
                                                                                                   'hashname' => '__ACTION1__'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'patcount' => 1,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'number' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'OPFUNCTION',
                                                       'calls' => [],
                                                       'impcount' => 0,
                                                       'line' => 767,
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'opcount' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'OPERATOR' => bless( {
                                                     'opcount' => 0,
                                                     'impcount' => 0,
                                                     'calls' => [],
                                                     'name' => 'OPERATOR',
                                                     'prods' => [
                                                                  bless( {
                                                                           'actcount' => 1,
                                                                           'strcount' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => undef,
                                                                           'number' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'description' => '/OPERATOR:\\\\S*:\\\\d+/',
                                                                                                 'line' => 783,
                                                                                                 'lookahead' => 0,
                                                                                                 'mod' => '',
                                                                                                 'rdelim' => '/',
                                                                                                 'ldelim' => '/',
                                                                                                 'pattern' => 'OPERATOR:\\S*:\\d+',
                                                                                                 'hashname' => '__PATTERN1__'
                                                                                               }, 'Parse::RecDescent::Token' ),
                                                                                        bless( {
                                                                                                 'code' => '{ Lookup($item[1]); }',
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'line' => 783,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 1
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'line' => 783
                                                   }, 'Parse::RecDescent::Rule' ),
                              'addIntOpArgs' => bless( {
                                                         'opcount' => 0,
                                                         'impcount' => 0,
                                                         'prods' => [
                                                                      bless( {
                                                                               'line' => undef,
                                                                               'uncommit' => undef,
                                                                               'number' => 0,
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'error' => undef,
                                                                               'dircount' => 0,
                                                                               'patcount' => 1,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'hashname' => '__PATTERN1__',
                                                                                                     'line' => 610,
                                                                                                     'description' => '/^\\\\Z/',
                                                                                                     'lookahead' => 0,
                                                                                                     'mod' => '',
                                                                                                     'ldelim' => '/',
                                                                                                     'rdelim' => '/',
                                                                                                     'pattern' => '^\\Z'
                                                                                                   }, 'Parse::RecDescent::Token' ),
                                                                                            bless( {
                                                                                                     'line' => 610,
                                                                                                     'lookahead' => 0,
                                                                                                     'code' => '{ $arg[0];}',
                                                                                                     'hashname' => '__ACTION1__'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'repspec' => '?',
                                                                                                     'expected' => undef,
                                                                                                     'subrule' => 'APPLYOP',
                                                                                                     'matchrule' => 0,
                                                                                                     'line' => 612,
                                                                                                     'lookahead' => 0,
                                                                                                     'argcode' => undef,
                                                                                                     'max' => 1,
                                                                                                     'min' => 0
                                                                                                   }, 'Parse::RecDescent::Repetition' ),
                                                                                            bless( {
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'IntFactor',
                                                                                                     'line' => 612,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'subrule' => 'moreIntOpArgFactors',
                                                                                                     'matchrule' => 0,
                                                                                                     'argcode' => '[$item[2]]',
                                                                                                     'implicit' => undef,
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 612
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 612,
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ Apply($arg[0],$item[3]);}'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'number' => 1,
                                                                               'uncommit' => undef,
                                                                               'line' => 611,
                                                                               'actcount' => 1,
                                                                               'strcount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'number' => 2,
                                                                               'line' => 613,
                                                                               'uncommit' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'line' => 613,
                                                                                                     'lookahead' => 0,
                                                                                                     'code' => '{ $arg[0]; }',
                                                                                                     'hashname' => '__ACTION1__'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'name' => 'addIntOpArgs',
                                                         'calls' => [
                                                                      'APPLYOP',
                                                                      'IntFactor',
                                                                      'moreIntOpArgFactors'
                                                                    ],
                                                         'changed' => 0,
                                                         'vars' => '',
                                                         'line' => 608
                                                       }, 'Parse::RecDescent::Rule' ),
                              'FUNCTION' => bless( {
                                                     'calls' => [],
                                                     'name' => 'FUNCTION',
                                                     'prods' => [
                                                                  bless( {
                                                                           'strcount' => 0,
                                                                           'actcount' => 1,
                                                                           'line' => undef,
                                                                           'uncommit' => undef,
                                                                           'number' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'line' => 766,
                                                                                                 'description' => '/FUNCTION:\\\\S*:\\\\d+/',
                                                                                                 'mod' => '',
                                                                                                 'lookahead' => 0,
                                                                                                 'rdelim' => '/',
                                                                                                 'ldelim' => '/',
                                                                                                 'pattern' => 'FUNCTION:\\S*:\\d+',
                                                                                                 'hashname' => '__PATTERN1__'
                                                                                               }, 'Parse::RecDescent::Token' ),
                                                                                        bless( {
                                                                                                 'code' => '{ Lookup($item[1]); }',
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'line' => 766,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 1
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'impcount' => 0,
                                                     'line' => 766,
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'POSTSUBSCRIPT' => bless( {
                                                          'opcount' => 0,
                                                          'changed' => 0,
                                                          'vars' => '',
                                                          'line' => 784,
                                                          'impcount' => 0,
                                                          'name' => 'POSTSUBSCRIPT',
                                                          'prods' => [
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'pattern' => 'POSTSUBSCRIPT:\\S*:\\d+',
                                                                                                      'ldelim' => '/',
                                                                                                      'rdelim' => '/',
                                                                                                      'mod' => '',
                                                                                                      'lookahead' => 0,
                                                                                                      'description' => '/POSTSUBSCRIPT:\\\\S*:\\\\d+/',
                                                                                                      'line' => 785,
                                                                                                      'hashname' => '__PATTERN1__'
                                                                                                    }, 'Parse::RecDescent::Token' ),
                                                                                             bless( {
                                                                                                      'line' => 785,
                                                                                                      'lookahead' => 0,
                                                                                                      'code' => '{ Lookup($item[1]); }',
                                                                                                      'hashname' => '__ACTION1__'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 1,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'number' => 0
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'calls' => []
                                                        }, 'Parse::RecDescent::Rule' ),
                              'SINGLEVERTBAR' => bless( {
                                                          'opcount' => 0,
                                                          'changed' => 0,
                                                          'vars' => '',
                                                          'line' => 777,
                                                          'impcount' => 0,
                                                          'prods' => [
                                                                       bless( {
                                                                                'number' => 0,
                                                                                'line' => undef,
                                                                                'uncommit' => undef,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1,
                                                                                'patcount' => 1,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'hashname' => '__PATTERN1__',
                                                                                                      'pattern' => 'VERTBAR:\\|:\\d+',
                                                                                                      'ldelim' => '/',
                                                                                                      'rdelim' => '/',
                                                                                                      'mod' => '',
                                                                                                      'lookahead' => 0,
                                                                                                      'description' => '/VERTBAR:\\\\|:\\\\d+/',
                                                                                                      'line' => 777
                                                                                                    }, 'Parse::RecDescent::Token' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 777,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ Lookup($item[1]); }'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'name' => 'SINGLEVERTBAR',
                                                          'calls' => []
                                                        }, 'Parse::RecDescent::Rule' ),
                              'Anything' => bless( {
                                                     'changed' => 0,
                                                     'vars' => ' local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH;
',
                                                     'line' => 62,
                                                     'impcount' => 0,
                                                     'name' => 'Anything',
                                                     'prods' => [
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'name' => '<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>',
                                                                                                 'hashname' => '__DIRECTIVE1__',
                                                                                                 'line' => 63,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::UncondReject' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'dircount' => 1,
                                                                           'error' => undef,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'number' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => undef
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 64,
                                                                                                 'subrule' => 'AnythingAny',
                                                                                                 'matchrule' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'hashname' => '__PATTERN1__',
                                                                                                 'lookahead' => 0,
                                                                                                 'mod' => '',
                                                                                                 'description' => '/^\\\\Z/',
                                                                                                 'line' => 64,
                                                                                                 'pattern' => '^\\Z',
                                                                                                 'rdelim' => '/',
                                                                                                 'ldelim' => '/'
                                                                                               }, 'Parse::RecDescent::Token' ),
                                                                                        bless( {
                                                                                                 'code' => '{ $item[1]; }',
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'line' => 64,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'patcount' => 1,
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'actcount' => 1,
                                                                           'strcount' => 0,
                                                                           'number' => 1,
                                                                           'uncommit' => undef,
                                                                           'line' => undef
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'calls' => [
                                                                  'AnythingAny'
                                                                ],
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'BINOP' => bless( {
                                                  'calls' => [],
                                                  'name' => 'BINOP',
                                                  'prods' => [
                                                               bless( {
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => 'BINOP:\\S*:\\d+',
                                                                                              'description' => '/BINOP:\\\\S*:\\\\d+/',
                                                                                              'line' => 764,
                                                                                              'lookahead' => 0,
                                                                                              'mod' => ''
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'line' => 764,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'error' => undef,
                                                                        'dircount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'impcount' => 0,
                                                  'line' => 764,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'moreFormulae' => bless( {
                                                         'changed' => 0,
                                                         'vars' => '',
                                                         'line' => 118,
                                                         'impcount' => 0,
                                                         'prods' => [
                                                                      bless( {
                                                                               'uncommit' => undef,
                                                                               'line' => undef,
                                                                               'number' => 0,
                                                                               'actcount' => 1,
                                                                               'strcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 1,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'ldelim' => '/',
                                                                                                     'rdelim' => '/',
                                                                                                     'pattern' => '^\\Z',
                                                                                                     'description' => '/^\\\\Z/',
                                                                                                     'line' => 120,
                                                                                                     'lookahead' => 0,
                                                                                                     'mod' => '',
                                                                                                     'hashname' => '__PATTERN1__'
                                                                                                   }, 'Parse::RecDescent::Token' ),
                                                                                            bless( {
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ $arg[0];}',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 120
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'number' => 1,
                                                                               'line' => 120,
                                                                               'uncommit' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'max' => 100000000,
                                                                                                     'argcode' => undef,
                                                                                                     'min' => 1,
                                                                                                     'subrule' => '_alternation_1_of_production_2_of_rule_moreFormulae',
                                                                                                     'matchrule' => 0,
                                                                                                     'expected' => 'endPunct',
                                                                                                     'repspec' => 's',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 121
                                                                                                   }, 'Parse::RecDescent::Repetition' ),
                                                                                            bless( {
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ NewFormulae($arg[0],map(@$_,@{$item[1]})); }',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 122
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'actcount' => 1,
                                                                               'strcount' => 0,
                                                                               'uncommit' => undef,
                                                                               'line' => 123,
                                                                               'number' => 2,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'min' => 1,
                                                                                                     'argcode' => undef,
                                                                                                     'max' => 100000000,
                                                                                                     'line' => 123,
                                                                                                     'lookahead' => 0,
                                                                                                     'repspec' => 's',
                                                                                                     'expected' => undef,
                                                                                                     'subrule' => 'metarelopFormula',
                                                                                                     'matchrule' => 0
                                                                                                   }, 'Parse::RecDescent::Repetition' ),
                                                                                            bless( {
                                                                                                     'code' => '{ NewFormula($arg[0],map(@$_,@{$item[1]})); }',
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'line' => 123,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 0
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'number' => 3,
                                                                               'line' => 124,
                                                                               'uncommit' => undef,
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'patcount' => 0,
                                                                               'error' => undef,
                                                                               'dircount' => 0,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'line' => 124,
                                                                                                     'lookahead' => 0,
                                                                                                     'code' => '{ $arg[0]; }',
                                                                                                     'hashname' => '__ACTION1__'
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'name' => 'moreFormulae',
                                                         'calls' => [
                                                                      '_alternation_1_of_production_2_of_rule_moreFormulae',
                                                                      'metarelopFormula'
                                                                    ],
                                                         'opcount' => 0
                                                       }, 'Parse::RecDescent::Rule' ),
                              'IntFactor' => bless( {
                                                      'opcount' => 0,
                                                      'line' => 623,
                                                      'changed' => 0,
                                                      'vars' => '',
                                                      'name' => 'IntFactor',
                                                      'prods' => [
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 625,
                                                                                                  'subrule' => 'diffd',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'line' => 626,
                                                                                                  'lookahead' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef,
                                                                                                  'subrule' => 'ATOM_OR_ID',
                                                                                                  'matchrule' => 0
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'line' => 626,
                                                                                                  'lookahead' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => '[$item[2]]',
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'addScripts'
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'code' => '{ Apply(Annotate($item[1],role=>\'DIFFOP\',meaning=>\'differential-d\'),$item[3]); }',
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'line' => 627,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'patcount' => 0,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'number' => 0
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 628,
                                                                                                  'subrule' => 'diffd',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef,
                                                                                                  'subrule' => 'UNKNOWN',
                                                                                                  'matchrule' => 0,
                                                                                                  'line' => 628,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'line' => 628,
                                                                                                  'lookahead' => 0,
                                                                                                  'argcode' => '[$item[2]]',
                                                                                                  'implicit' => undef,
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'addScripts'
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'code' => '{ Apply(Annotate($item[1],role=>\'DIFFOP\',meaning=>\'differential-d\'),$item[3]); }',
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'line' => 629,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'patcount' => 0,
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'actcount' => 1,
                                                                            'strcount' => 0,
                                                                            'number' => 1,
                                                                            'uncommit' => undef,
                                                                            'line' => 628
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef,
                                                                                                  'subrule' => 'Factor',
                                                                                                  'matchrule' => 0,
                                                                                                  'line' => 630,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ $item[1]; }',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 630
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'line' => 630,
                                                                            'uncommit' => undef,
                                                                            'number' => 2,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'calls' => [
                                                                   'diffd',
                                                                   'ATOM_OR_ID',
                                                                   'addScripts',
                                                                   'UNKNOWN',
                                                                   'Factor'
                                                                 ],
                                                      'impcount' => 0
                                                    }, 'Parse::RecDescent::Rule' ),
                              'MIDBAR' => bless( {
                                                   'opcount' => 0,
                                                   'line' => 753,
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'name' => 'MIDBAR',
                                                   'prods' => [
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'line' => 753,
                                                                                               'description' => '/VERTBAR:\\\\S*:\\\\d+/',
                                                                                               'pattern' => 'VERTBAR:\\S*:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'line' => 753,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'patcount' => 1,
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'number' => 0,
                                                                         'line' => undef,
                                                                         'uncommit' => undef
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'line' => 754,
                                                                         'uncommit' => undef,
                                                                         'number' => 1,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'patcount' => 1,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'mod' => '',
                                                                                               'lookahead' => 0,
                                                                                               'description' => '/MIDDLE:\\\\|:\\\\d+/',
                                                                                               'line' => 754,
                                                                                               'pattern' => 'MIDDLE:\\|:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/',
                                                                                               'hashname' => '__PATTERN1__'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 754,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ Lookup($item[1]); }'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' ),
                                                                bless( {
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'number' => 2,
                                                                         'uncommit' => undef,
                                                                         'line' => 755,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'ldelim' => '/',
                                                                                               'rdelim' => '/',
                                                                                               'pattern' => 'MIDDLE:parallel-to:\\d+',
                                                                                               'line' => 755,
                                                                                               'description' => '/MIDDLE:parallel-to:\\\\d+/',
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'hashname' => '__PATTERN1__'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 755,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ Lookup($item[1]); }'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'patcount' => 1,
                                                                         'dircount' => 0,
                                                                         'error' => undef
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'calls' => [],
                                                   'impcount' => 0
                                                 }, 'Parse::RecDescent::Rule' ),
                              'moreFactors' => bless( {
                                                        'line' => 248,
                                                        'changed' => 0,
                                                        'vars' => '',
                                                        'prods' => [
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'ldelim' => '/',
                                                                                                    'rdelim' => '/',
                                                                                                    'pattern' => '^\\Z',
                                                                                                    'line' => 250,
                                                                                                    'description' => '/^\\\\Z/',
                                                                                                    'lookahead' => 0,
                                                                                                    'mod' => '',
                                                                                                    'hashname' => '__PATTERN1__'
                                                                                                  }, 'Parse::RecDescent::Token' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 250,
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ $arg[0];}'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'patcount' => 1,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'number' => 1,
                                                                              'line' => 250,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 0,
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'MulOp',
                                                                                                    'line' => 251,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 251,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'Factor',
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 251,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'moreFactors',
                                                                                                    'argcode' => '[ApplyNary($item[1],$arg[0],$item[2])]',
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'number' => 2,
                                                                              'line' => 253,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 0,
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 254,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'COMPOSEOP'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'subrule' => 'makeComposition',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => '[$arg[0],$item[1]]',
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 254
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 255,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ ($forbidEvalAt ? undef : 1); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 256,
                                                                                                    'subrule' => 'evalAtOp',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'subrule' => 'maybeEvalAt',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => '[$arg[0],$item[2]]',
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 256
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'number' => 3,
                                                                              'uncommit' => undef,
                                                                              'line' => 255,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'subrule' => 'Factor',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 257,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[ApplyNary(InvisibleTimes(),$arg[0],$item[1])]',
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'moreFactors',
                                                                                                    'line' => 257,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'number' => 4,
                                                                              'uncommit' => undef,
                                                                              'line' => 257,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 258,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ $arg[0]; }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'line' => 258,
                                                                              'uncommit' => undef,
                                                                              'number' => 5,
                                                                              'strcount' => 0,
                                                                              'actcount' => 1
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'name' => 'moreFactors',
                                                        'calls' => [
                                                                     'MulOp',
                                                                     'Factor',
                                                                     'moreFactors',
                                                                     'COMPOSEOP',
                                                                     'makeComposition',
                                                                     'evalAtOp',
                                                                     'maybeEvalAt'
                                                                   ],
                                                        'impcount' => 0,
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              'AnythingAny' => bless( {
                                                        'calls' => [
                                                                     'Formulae',
                                                                     'OPEN',
                                                                     'CLOSE',
                                                                     'modifierFormulae',
                                                                     'modifierFormula',
                                                                     'MODIFIER',
                                                                     'MODIFIEROP',
                                                                     'Expression',
                                                                     'METARELOP',
                                                                     'Formula',
                                                                     'AnyOp',
                                                                     '_alternation_1_of_production_8_of_rule_AnythingAny',
                                                                     'FLOATSUPERSCRIPT',
                                                                     'POSTSUBSCRIPT',
                                                                     'FLOATSUBSCRIPT',
                                                                     'POSTSUPERSCRIPT'
                                                                   ],
                                                        'name' => 'AnythingAny',
                                                        'prods' => [
                                                                     bless( {
                                                                              'patcount' => 0,
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 68,
                                                                                                    'subrule' => 'Formulae',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'number' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'uncommit' => undef,
                                                                              'line' => 69,
                                                                              'number' => 1,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'OPEN',
                                                                                                    'line' => 69,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'Formulae',
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 69
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 69,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'CLOSE',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ Fence($item[1],$item[2],$item[3]); }',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 69
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'uncommit' => undef,
                                                                              'line' => 70,
                                                                              'number' => 2,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'modifierFormulae',
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 70
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'number' => 3,
                                                                              'uncommit' => undef,
                                                                              'line' => 71,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'OPEN',
                                                                                                    'line' => 71,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'modifierFormula',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 71,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'CLOSE',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 71,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ Fence($item[1],$item[2],$item[3]); }',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 71
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'subrule' => 'MODIFIER',
                                                                                                    'matchrule' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 72
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0,
                                                                              'number' => 4,
                                                                              'uncommit' => undef,
                                                                              'line' => 72
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'MODIFIEROP',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 73
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'Expression',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 73,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ Apply($item[1],Absent(),$item[2]);}',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 73
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => 73,
                                                                              'number' => 5
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'patcount' => 0,
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'subrule' => 'METARELOP',
                                                                                                    'matchrule' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 74
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'subrule' => 'Formula',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 74,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 74,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ Apply($item[1],Absent(),$item[2]); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'number' => 6,
                                                                              'line' => 74,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 1
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'number' => 7,
                                                                              'line' => 75,
                                                                              'uncommit' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 75,
                                                                                                    'subrule' => 'AnyOp',
                                                                                                    'matchrule' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'max' => 100000000,
                                                                                                    'argcode' => undef,
                                                                                                    'min' => 1,
                                                                                                    'subrule' => '_alternation_1_of_production_8_of_rule_AnythingAny',
                                                                                                    'matchrule' => 0,
                                                                                                    'repspec' => 's',
                                                                                                    'expected' => 'PUNCT',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 75
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 76,
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ NewList($item[1],map(@$_,@{$item[2]})); }'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'line' => 77,
                                                                              'uncommit' => undef,
                                                                              'number' => 8,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 77,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'FLOATSUPERSCRIPT'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 77,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'POSTSUBSCRIPT',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'code' => '{ NewScript(NewScript(Absent(),$item[1]),$item[2]); }',
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'line' => 77,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'number' => 9,
                                                                              'line' => 78,
                                                                              'uncommit' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 78,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'FLOATSUBSCRIPT',
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 78,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'POSTSUPERSCRIPT',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ NewScript(NewScript(Absent(),$item[1]),$item[2]); }',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 78
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 79,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'subrule' => 'FLOATSUPERSCRIPT',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 79,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ NewScript(Absent(),$item[1]); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'number' => 10,
                                                                              'line' => 79,
                                                                              'uncommit' => undef
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'number' => 11,
                                                                              'line' => 80,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 80,
                                                                                                    'subrule' => 'FLOATSUBSCRIPT',
                                                                                                    'matchrule' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 80,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ NewScript(Absent(),$item[1]); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'AnyOp',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 81,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 81,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'Expression',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'code' => '{ Apply($item[1],Absent(),$item[2]);}',
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'line' => 81,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'number' => 12,
                                                                              'uncommit' => undef,
                                                                              'line' => 81
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'impcount' => 0,
                                                        'line' => 66,
                                                        'vars' => '',
                                                        'changed' => 0,
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_1_of_rule_requireArgs' => bless( {
                                                                                               'impcount' => 0,
                                                                                               'name' => '_alternation_1_of_production_1_of_rule_requireArgs',
                                                                                               'prods' => [
                                                                                                            bless( {
                                                                                                                     'actcount' => 1,
                                                                                                                     'strcount' => 0,
                                                                                                                     'number' => 0,
                                                                                                                     'uncommit' => undef,
                                                                                                                     'line' => undef,
                                                                                                                     'items' => [
                                                                                                                                  bless( {
                                                                                                                                           'implicit' => undef,
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'subrule' => 'argPunct',
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0
                                                                                                                                         }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                  bless( {
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'subrule' => 'Argument',
                                                                                                                                           'implicit' => undef,
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'line' => 791
                                                                                                                                         }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                  bless( {
                                                                                                                                           'code' => '{[$item[1],$item[2]];}',
                                                                                                                                           'hashname' => '__ACTION1__',
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0
                                                                                                                                         }, 'Parse::RecDescent::Action' )
                                                                                                                                ],
                                                                                                                     'patcount' => 0,
                                                                                                                     'dircount' => 0,
                                                                                                                     'error' => undef
                                                                                                                   }, 'Parse::RecDescent::Production' )
                                                                                                          ],
                                                                                               'calls' => [
                                                                                                            'argPunct',
                                                                                                            'Argument'
                                                                                                          ],
                                                                                               'changed' => 0,
                                                                                               'vars' => '',
                                                                                               'line' => 791,
                                                                                               'opcount' => 0
                                                                                             }, 'Parse::RecDescent::Rule' ),
                              'LIMITOP' => bless( {
                                                    'opcount' => 0,
                                                    'prods' => [
                                                                 bless( {
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 1,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'mod' => '',
                                                                                                'line' => 781,
                                                                                                'description' => '/LIMITOP:\\\\S*:\\\\d+/',
                                                                                                'pattern' => 'LIMITOP:\\S*:\\d+',
                                                                                                'ldelim' => '/',
                                                                                                'rdelim' => '/',
                                                                                                'hashname' => '__PATTERN1__'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 781,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ Lookup($item[1]); }'
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'uncommit' => undef,
                                                                          'line' => undef,
                                                                          'number' => 0,
                                                                          'actcount' => 1,
                                                                          'strcount' => 0
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'name' => 'LIMITOP',
                                                    'calls' => [],
                                                    'impcount' => 0,
                                                    'line' => 781,
                                                    'changed' => 0,
                                                    'vars' => ''
                                                  }, 'Parse::RecDescent::Rule' ),
                              'makeComposition' => bless( {
                                                            'opcount' => 0,
                                                            'prods' => [
                                                                         bless( {
                                                                                  'actcount' => 1,
                                                                                  'strcount' => 0,
                                                                                  'number' => 0,
                                                                                  'uncommit' => undef,
                                                                                  'line' => undef,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'line' => 577,
                                                                                                        'lookahead' => 0,
                                                                                                        'argcode' => '[\'FUNCTION\']',
                                                                                                        'implicit' => undef,
                                                                                                        'subrule' => 'preScripted',
                                                                                                        'matchrule' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'argcode' => '[Apply($arg[1],$arg[0],$item[1])]',
                                                                                                        'implicit' => undef,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'addArgs',
                                                                                                        'line' => 577,
                                                                                                        'lookahead' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'line' => 578,
                                                                                                        'lookahead' => 0,
                                                                                                        'code' => '{ $item[2]; }',
                                                                                                        'hashname' => '__ACTION1__'
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ],
                                                                                  'patcount' => 0,
                                                                                  'dircount' => 0,
                                                                                  'error' => undef
                                                                                }, 'Parse::RecDescent::Production' ),
                                                                         bless( {
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'patcount' => 0,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'implicit' => undef,
                                                                                                        'argcode' => '[\'OPFUNCTION\']',
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'preScripted',
                                                                                                        'line' => 579,
                                                                                                        'lookahead' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'subrule' => 'addOpFunArgs',
                                                                                                        'matchrule' => 0,
                                                                                                        'argcode' => '[Apply($arg[1],$arg[0],$item[1])]',
                                                                                                        'implicit' => undef,
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 579
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'hashname' => '__ACTION1__',
                                                                                                        'code' => '{ $item[2]; }',
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 580
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ],
                                                                                  'uncommit' => undef,
                                                                                  'line' => 579,
                                                                                  'number' => 1,
                                                                                  'actcount' => 1,
                                                                                  'strcount' => 0
                                                                                }, 'Parse::RecDescent::Production' ),
                                                                         bless( {
                                                                                  'actcount' => 1,
                                                                                  'strcount' => 0,
                                                                                  'number' => 2,
                                                                                  'uncommit' => undef,
                                                                                  'line' => 581,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'argcode' => '[\'TRIGFUNCTION\']',
                                                                                                        'implicit' => undef,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'preScripted',
                                                                                                        'line' => 581,
                                                                                                        'lookahead' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'argcode' => '[Apply($arg[1],$arg[0],$item[1])]',
                                                                                                        'implicit' => undef,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'addTrigFunArgs',
                                                                                                        'line' => 582,
                                                                                                        'lookahead' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'code' => '{ $item[2]; }',
                                                                                                        'hashname' => '__ACTION1__',
                                                                                                        'line' => 582,
                                                                                                        'lookahead' => 0
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ],
                                                                                  'patcount' => 0,
                                                                                  'error' => undef,
                                                                                  'dircount' => 0
                                                                                }, 'Parse::RecDescent::Production' ),
                                                                         bless( {
                                                                                  'number' => 3,
                                                                                  'line' => 584,
                                                                                  'uncommit' => undef,
                                                                                  'strcount' => 0,
                                                                                  'actcount' => 1,
                                                                                  'patcount' => 0,
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'line' => 585,
                                                                                                        'lookahead' => 0,
                                                                                                        'argcode' => undef,
                                                                                                        'implicit' => undef,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'Factor'
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'line' => 585,
                                                                                                        'lookahead' => 0,
                                                                                                        'argcode' => '[Apply($arg[1],$arg[0],$item[1])]',
                                                                                                        'implicit' => undef,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'addArgs'
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'line' => 585,
                                                                                                        'lookahead' => 0,
                                                                                                        'code' => '{ $item[2]; }',
                                                                                                        'hashname' => '__ACTION1__'
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ]
                                                                                }, 'Parse::RecDescent::Production' )
                                                                       ],
                                                            'name' => 'makeComposition',
                                                            'calls' => [
                                                                         'preScripted',
                                                                         'addArgs',
                                                                         'addOpFunArgs',
                                                                         'addTrigFunArgs',
                                                                         'Factor'
                                                                       ],
                                                            'impcount' => 0,
                                                            'line' => 575,
                                                            'changed' => 0,
                                                            'vars' => ''
                                                          }, 'Parse::RecDescent::Rule' ),
                              'SUPOP' => bless( {
                                                  'opcount' => 0,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'line' => 771,
                                                  'impcount' => 0,
                                                  'calls' => [],
                                                  'name' => 'SUPOP',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'pattern' => 'SUPOP:\\S*:\\d+',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/',
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'line' => 771,
                                                                                              'description' => '/SUPOP:\\\\S*:\\\\d+/'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'line' => 771,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 1,
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'line' => undef,
                                                                        'uncommit' => undef,
                                                                        'number' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ]
                                                }, 'Parse::RecDescent::Rule' ),
                              'endPunct' => bless( {
                                                     'impcount' => 0,
                                                     'calls' => [
                                                                  'PUNCT',
                                                                  'PERIOD'
                                                                ],
                                                     'prods' => [
                                                                  bless( {
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'patcount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 127,
                                                                                                 'subrule' => 'PUNCT',
                                                                                                 'matchrule' => 0,
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'uncommit' => undef,
                                                                           'line' => undef,
                                                                           'number' => 0,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 127,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'PERIOD',
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'number' => 1,
                                                                           'uncommit' => undef,
                                                                           'line' => 127
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'name' => 'endPunct',
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'line' => 126,
                                                     'opcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'absExpression' => bless( {
                                                          'opcount' => 0,
                                                          'line' => 397,
                                                          'changed' => 0,
                                                          'vars' => ' local $forbidEvalAt = 1;
 local $MaxAbsDepth = $MaxAbsDepth-1;
',
                                                          'name' => 'absExpression',
                                                          'prods' => [
                                                                       bless( {
                                                                                'dircount' => 1,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'hashname' => '__DIRECTIVE1__',
                                                                                                      'name' => '<rulevar: local $forbidEvalAt = 1>',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 398
                                                                                                    }, 'Parse::RecDescent::UncondReject' )
                                                                                           ],
                                                                                'line' => undef,
                                                                                'uncommit' => undef,
                                                                                'number' => 0,
                                                                                'strcount' => 0,
                                                                                'actcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'number' => 1,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0,
                                                                                'patcount' => 0,
                                                                                'dircount' => 1,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 399,
                                                                                                      'lookahead' => 0,
                                                                                                      'name' => '<rulevar: local $MaxAbsDepth = $MaxAbsDepth-1>',
                                                                                                      'hashname' => '__DIRECTIVE1__'
                                                                                                    }, 'Parse::RecDescent::UncondReject' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 400,
                                                                                                      'lookahead' => 0,
                                                                                                      'code' => '{ ($MaxAbsDepth >= 0 ? 1 : (SawNotation(\'AbsFail\')&& undef)); }',
                                                                                                      'hashname' => '__ACTION1__'
                                                                                                    }, 'Parse::RecDescent::Action' ),
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'subrule' => 'Expression',
                                                                                                      'matchrule' => 0,
                                                                                                      'line' => 400,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1,
                                                                                'line' => undef,
                                                                                'uncommit' => undef,
                                                                                'number' => 2
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'calls' => [
                                                                       'Expression'
                                                                     ],
                                                          'impcount' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'maybeColRHS' => bless( {
                                                        'prods' => [
                                                                     bless( {
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 1,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'pattern' => '^\\Z',
                                                                                                    'rdelim' => '/',
                                                                                                    'ldelim' => '/',
                                                                                                    'mod' => '',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 164,
                                                                                                    'description' => '/^\\\\Z/',
                                                                                                    'hashname' => '__PATTERN1__'
                                                                                                  }, 'Parse::RecDescent::Token' ),
                                                                                           bless( {
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ NewFormula($arg[0],$arg[1],NewList(@arg[2..$#arg])); }',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 164
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 0,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'line' => 165,
                                                                              'uncommit' => undef,
                                                                              'number' => 1,
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'relop',
                                                                                                    'line' => 165,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 165,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'Expression',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 165,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => '[$arg[$#arg],$item[1],$item[2]]',
                                                                                                    'implicit' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'moreRHS'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 166,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ NewFormulae(NewFormula($arg[0],$arg[1],
                          NewList(@arg[2..$#arg-2])),$arg[$#arg-1],$item[3]); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'actcount' => 0,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => 168,
                                                                              'number' => 2,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 168,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'PUNCT'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'Expression',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 168,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'maybeColRHS',
                                                                                                    'argcode' => '[@arg,$item[1],$item[2]]',
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 168
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'uncommit' => undef,
                                                                              'line' => 169,
                                                                              'number' => 3,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'patcount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 169,
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ NewFormula($arg[0],$arg[1],NewList(@arg[2..$#arg])); }'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'name' => 'maybeColRHS',
                                                        'calls' => [
                                                                     'relop',
                                                                     'Expression',
                                                                     'moreRHS',
                                                                     'PUNCT',
                                                                     'maybeColRHS'
                                                                   ],
                                                        'impcount' => 0,
                                                        'line' => 162,
                                                        'changed' => 0,
                                                        'vars' => '',
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              'Expressions' => bless( {
                                                        'opcount' => 0,
                                                        'impcount' => 0,
                                                        'calls' => [
                                                                     'Expression',
                                                                     'punctExpr'
                                                                   ],
                                                        'name' => 'Expressions',
                                                        'prods' => [
                                                                     bless( {
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 0,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 195,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'Expression',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'min' => 0,
                                                                                                    'max' => 100000000,
                                                                                                    'argcode' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 195,
                                                                                                    'subrule' => 'punctExpr',
                                                                                                    'matchrule' => 0,
                                                                                                    'repspec' => 's?',
                                                                                                    'expected' => undef
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
                                                                                           bless( {
                                                                                                    'code' => '{ NewList($item[1],map(@$_,@{$item[2]})); }',
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'line' => 196,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'vars' => '',
                                                        'changed' => 0,
                                                        'line' => 193
                                                      }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_2_of_rule_addEasyArgs' => bless( {
                                                                                               'vars' => '',
                                                                                               'changed' => 0,
                                                                                               'line' => 791,
                                                                                               'impcount' => 0,
                                                                                               'calls' => [
                                                                                                            'argPunct',
                                                                                                            'Argument'
                                                                                                          ],
                                                                                               'name' => '_alternation_1_of_production_2_of_rule_addEasyArgs',
                                                                                               'prods' => [
                                                                                                            bless( {
                                                                                                                     'strcount' => 0,
                                                                                                                     'actcount' => 1,
                                                                                                                     'number' => 0,
                                                                                                                     'line' => undef,
                                                                                                                     'uncommit' => undef,
                                                                                                                     'items' => [
                                                                                                                                  bless( {
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'line' => 791,
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'subrule' => 'argPunct',
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'implicit' => undef
                                                                                                                                         }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                  bless( {
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'line' => 791,
                                                                                                                                           'subrule' => 'Argument',
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'implicit' => undef,
                                                                                                                                           'argcode' => undef
                                                                                                                                         }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                  bless( {
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'line' => 791,
                                                                                                                                           'hashname' => '__ACTION1__',
                                                                                                                                           'code' => '{[$item[1],$item[2]];}'
                                                                                                                                         }, 'Parse::RecDescent::Action' )
                                                                                                                                ],
                                                                                                                     'patcount' => 0,
                                                                                                                     'error' => undef,
                                                                                                                     'dircount' => 0
                                                                                                                   }, 'Parse::RecDescent::Production' )
                                                                                                          ],
                                                                                               'opcount' => 0
                                                                                             }, 'Parse::RecDescent::Rule' ),
                              'supops' => bless( {
                                                   'opcount' => 0,
                                                   'impcount' => 0,
                                                   'name' => 'supops',
                                                   'prods' => [
                                                                bless( {
                                                                         'uncommit' => undef,
                                                                         'line' => undef,
                                                                         'number' => 0,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'patcount' => 0,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'min' => 1,
                                                                                               'max' => 100000000,
                                                                                               'argcode' => undef,
                                                                                               'lookahead' => 0,
                                                                                               'line' => 700,
                                                                                               'matchrule' => 0,
                                                                                               'subrule' => 'SUPOP',
                                                                                               'expected' => undef,
                                                                                               'repspec' => 's'
                                                                                             }, 'Parse::RecDescent::Repetition' ),
                                                                                      bless( {
                                                                                               'line' => 700,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ New(undef,
                                                      join(\'\',map($_->textContent,@{$item[1]})),
                                                       name=>\'prime\'.scalar(@{$item[1]})); }',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'calls' => [
                                                                'SUPOP'
                                                              ],
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 699
                                                 }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_2_of_rule_Subscript' => bless( {
                                                                                             'impcount' => 0,
                                                                                             'calls' => [
                                                                                                          'PUNCT',
                                                                                                          'aSubscript'
                                                                                                        ],
                                                                                             'name' => '_alternation_1_of_production_2_of_rule_Subscript',
                                                                                             'prods' => [
                                                                                                          bless( {
                                                                                                                   'items' => [
                                                                                                                                bless( {
                                                                                                                                         'subrule' => 'PUNCT',
                                                                                                                                         'matchrule' => 0,
                                                                                                                                         'repspec' => '?',
                                                                                                                                         'expected' => undef,
                                                                                                                                         'lookahead' => 0,
                                                                                                                                         'line' => 791,
                                                                                                                                         'max' => 1,
                                                                                                                                         'argcode' => undef,
                                                                                                                                         'min' => 0
                                                                                                                                       }, 'Parse::RecDescent::Repetition' ),
                                                                                                                                bless( {
                                                                                                                                         'subrule' => 'aSubscript',
                                                                                                                                         'matchrule' => 0,
                                                                                                                                         'argcode' => undef,
                                                                                                                                         'implicit' => undef,
                                                                                                                                         'lookahead' => 0,
                                                                                                                                         'line' => 791
                                                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                bless( {
                                                                                                                                         'lookahead' => 0,
                                                                                                                                         'line' => 791,
                                                                                                                                         'hashname' => '__ACTION1__',
                                                                                                                                         'code' => '{[$item[1]->[0] || InvisibleComma(),$item[2]]; }'
                                                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                                                              ],
                                                                                                                   'patcount' => 0,
                                                                                                                   'dircount' => 0,
                                                                                                                   'error' => undef,
                                                                                                                   'strcount' => 0,
                                                                                                                   'actcount' => 1,
                                                                                                                   'number' => 0,
                                                                                                                   'line' => undef,
                                                                                                                   'uncommit' => undef
                                                                                                                 }, 'Parse::RecDescent::Production' )
                                                                                                        ],
                                                                                             'vars' => '',
                                                                                             'changed' => 0,
                                                                                             'line' => 791,
                                                                                             'opcount' => 0
                                                                                           }, 'Parse::RecDescent::Rule' ),
                              'VERTBAR' => bless( {
                                                    'opcount' => 0,
                                                    'prods' => [
                                                                 bless( {
                                                                          'strcount' => 0,
                                                                          'actcount' => 1,
                                                                          'line' => undef,
                                                                          'uncommit' => undef,
                                                                          'number' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'hashname' => '__PATTERN1__',
                                                                                                'lookahead' => 0,
                                                                                                'mod' => '',
                                                                                                'line' => 776,
                                                                                                'description' => '/VERTBAR:\\\\S*:\\\\d+/',
                                                                                                'pattern' => 'VERTBAR:\\S*:\\d+',
                                                                                                'rdelim' => '/',
                                                                                                'ldelim' => '/'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 776,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ Lookup($item[1]); }'
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 1
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'name' => 'VERTBAR',
                                                    'calls' => [],
                                                    'impcount' => 0,
                                                    'line' => 776,
                                                    'changed' => 0,
                                                    'vars' => ''
                                                  }, 'Parse::RecDescent::Rule' ),
                              'RBRACE' => bless( {
                                                   'vars' => '',
                                                   'changed' => 0,
                                                   'line' => 757,
                                                   'impcount' => 0,
                                                   'calls' => [],
                                                   'name' => 'RBRACE',
                                                   'prods' => [
                                                                bless( {
                                                                         'number' => 0,
                                                                         'line' => undef,
                                                                         'uncommit' => undef,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'patcount' => 1,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'line' => 757,
                                                                                               'description' => '/CLOSE:\\\\\\}:\\\\d+/',
                                                                                               'pattern' => 'CLOSE:\\}:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/',
                                                                                               'hashname' => '__PATTERN1__'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 757
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'opcount' => 0
                                                 }, 'Parse::RecDescent::Rule' ),
                              'APPLYOP' => bless( {
                                                    'vars' => '',
                                                    'changed' => 0,
                                                    'line' => 769,
                                                    'impcount' => 0,
                                                    'calls' => [],
                                                    'prods' => [
                                                                 bless( {
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 1,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'pattern' => 'APPLYOP:\\S*:\\d+',
                                                                                                'rdelim' => '/',
                                                                                                'ldelim' => '/',
                                                                                                'mod' => '',
                                                                                                'lookahead' => 0,
                                                                                                'description' => '/APPLYOP:\\\\S*:\\\\d+/',
                                                                                                'line' => 769,
                                                                                                'hashname' => '__PATTERN1__'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 769,
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ Lookup($item[1]); }'
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'line' => undef,
                                                                          'uncommit' => undef,
                                                                          'number' => 0,
                                                                          'strcount' => 0,
                                                                          'actcount' => 1
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'name' => 'APPLYOP',
                                                    'opcount' => 0
                                                  }, 'Parse::RecDescent::Rule' ),
                              'bigop' => bless( {
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'line' => 695,
                                                  'impcount' => 0,
                                                  'prods' => [
                                                               bless( {
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0,
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 696,
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef,
                                                                                              'subrule' => 'BIGOP',
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'number' => 1,
                                                                        'line' => 696,
                                                                        'uncommit' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'SUMOP',
                                                                                              'line' => 696,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'INTOP',
                                                                                              'line' => 696,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'patcount' => 0,
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => 696,
                                                                        'number' => 2
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 696,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'LIMITOP',
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'line' => 696,
                                                                        'uncommit' => undef,
                                                                        'number' => 3,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 696,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'DIFFOP',
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'line' => 696,
                                                                        'uncommit' => undef,
                                                                        'number' => 4,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'bigop',
                                                  'calls' => [
                                                               'BIGOP',
                                                               'SUMOP',
                                                               'INTOP',
                                                               'LIMITOP',
                                                               'DIFFOP'
                                                             ],
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'moreEvalAt' => bless( {
                                                       'opcount' => 0,
                                                       'changed' => 0,
                                                       'vars' => '',
                                                       'line' => 353,
                                                       'impcount' => 0,
                                                       'prods' => [
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'number' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'POSTSUPERSCRIPT',
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 355
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 355,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => '[NewEvalAt($arg[0],$arg[1],$arg[2],$item[1])]',
                                                                                                   'implicit' => undef,
                                                                                                   'subrule' => 'moreFactors',
                                                                                                   'matchrule' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'moreFactors',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[NewEvalAt($arg[0],$arg[1],$arg[2],undef)]',
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 356
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'uncommit' => undef,
                                                                             'line' => 356,
                                                                             'number' => 1,
                                                                             'actcount' => 0,
                                                                             'strcount' => 0
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'moreEvalAt',
                                                       'calls' => [
                                                                    'POSTSUPERSCRIPT',
                                                                    'moreFactors'
                                                                  ]
                                                     }, 'Parse::RecDescent::Rule' ),
                              'balancedClose' => bless( {
                                                          'opcount' => 0,
                                                          'line' => 707,
                                                          'changed' => 0,
                                                          'vars' => '',
                                                          'name' => 'balancedClose',
                                                          'prods' => [
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 708,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'subrule' => 'CLOSE',
                                                                                                      'matchrule' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'code' => '{ (isMatchingClose($arg[0],$item[1]) ? 1 : undef) }',
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'line' => 708,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Action' ),
                                                                                             bless( {
                                                                                                      'code' => '{ $item[1]; }',
                                                                                                      'hashname' => '__ACTION2__',
                                                                                                      'line' => 708,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'patcount' => 0,
                                                                                'error' => undef,
                                                                                'dircount' => 0,
                                                                                'actcount' => 2,
                                                                                'strcount' => 0,
                                                                                'number' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'calls' => [
                                                                       'CLOSE'
                                                                     ],
                                                          'impcount' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'CLOSE' => bless( {
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'line' => 774,
                                                  'impcount' => 0,
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'line' => 774,
                                                                                              'description' => '/CLOSE:\\\\S*:\\\\d+/',
                                                                                              'pattern' => 'CLOSE:\\S*:\\d+',
                                                                                              'ldelim' => '/',
                                                                                              'rdelim' => '/',
                                                                                              'hashname' => '__PATTERN1__'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 774
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'strcount' => 0,
                                                                        'actcount' => 1,
                                                                        'number' => 0,
                                                                        'line' => undef,
                                                                        'uncommit' => undef
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'CLOSE',
                                                  'calls' => [],
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'maybeBraket' => bless( {
                                                        'opcount' => 0,
                                                        'vars' => '',
                                                        'changed' => 0,
                                                        'line' => 368,
                                                        'impcount' => 0,
                                                        'calls' => [
                                                                     'RANGLE',
                                                                     'addScripts',
                                                                     'MIDBAR',
                                                                     'ketExpression'
                                                                   ],
                                                        'prods' => [
                                                                     bless( {
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 370,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'RANGLE'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 370,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ SawNotation(\'QM\'); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' ),
                                                                                           bless( {
                                                                                                    'line' => 371,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[InterpretDelimited(New(\'inner-product\', undef,role=>\'MIDDLE\'),
                                   Annotate($arg[0],role=>\'OPEN\'),$arg[1],
                                   Annotate($arg[2],role=>\'MIDDLE\'),
                                   $arg[3],Annotate($item[1],role=>\'CLOSE\'))]',
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'addScripts'
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => 375,
                                                                              'number' => 1,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 375,
                                                                                                    'lookahead' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'MIDBAR'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 375,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'ketExpression'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'subrule' => 'RANGLE',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 375
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 375,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ SawNotation(\'QM\'); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' ),
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'addScripts',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[InterpretDelimited(New(\'quantum-operator-product\',undef), # Is this a good representation?
                            Annotate($arg[0],role=>\'OPEN\'),$arg[1],
                                     Annotate($arg[2],role=>\'CLOSE\'),
                            $arg[3],
                            Annotate($item[1],role=>\'OPEN\'),$item[2],
                                    Annotate($item[3],role=>\'CLOSE\'))]',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 376
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'name' => 'maybeBraket'
                                                      }, 'Parse::RecDescent::Rule' ),
                              'doubtArgs' => bless( {
                                                      'opcount' => 0,
                                                      'impcount' => 0,
                                                      'name' => 'doubtArgs',
                                                      'prods' => [
                                                                   bless( {
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'number' => 0,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'pattern' => '^\\Z',
                                                                                                  'rdelim' => '/',
                                                                                                  'ldelim' => '/',
                                                                                                  'lookahead' => 0,
                                                                                                  'mod' => '',
                                                                                                  'description' => '/^\\\\Z/',
                                                                                                  'line' => 499,
                                                                                                  'hashname' => '__PATTERN1__'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 499,
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ $arg[0];}'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'patcount' => 1,
                                                                            'dircount' => 0,
                                                                            'error' => undef
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'APPLYOP',
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 500
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'subrule' => 'requireArgs',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => '[$arg[0]]',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 500
                                                                                                }, 'Parse::RecDescent::Subrule' )
                                                                                       ],
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'patcount' => 0,
                                                                            'strcount' => 0,
                                                                            'actcount' => 0,
                                                                            'line' => 499,
                                                                            'uncommit' => undef,
                                                                            'number' => 1
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'uncommit' => undef,
                                                                            'line' => 501,
                                                                            'number' => 2,
                                                                            'actcount' => 1,
                                                                            'strcount' => 0,
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ IsNotationAllowed(\'MaybeFunctions\'); }',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 501
                                                                                                }, 'Parse::RecDescent::Action' ),
                                                                                         bless( {
                                                                                                  'subrule' => 'OPEN',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 501
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'subrule' => 'forbidArgs',
                                                                                                  'matchrule' => 0,
                                                                                                  'argcode' => '[$arg[0],$item[2]]',
                                                                                                  'implicit' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 501
                                                                                                }, 'Parse::RecDescent::Subrule' )
                                                                                       ]
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'number' => 3,
                                                                            'uncommit' => undef,
                                                                            'line' => 502,
                                                                            'actcount' => 1,
                                                                            'strcount' => 0,
                                                                            'patcount' => 0,
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'line' => 502,
                                                                                                  'lookahead' => 0,
                                                                                                  'code' => '{ $arg[0]; }',
                                                                                                  'hashname' => '__ACTION1__'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ]
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'calls' => [
                                                                   'APPLYOP',
                                                                   'requireArgs',
                                                                   'OPEN',
                                                                   'forbidArgs'
                                                                 ],
                                                      'changed' => 0,
                                                      'vars' => '',
                                                      'line' => 497
                                                    }, 'Parse::RecDescent::Rule' ),
                              'aBarearg' => bless( {
                                                     'opcount' => 0,
                                                     'line' => 313,
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'calls' => [
                                                                  'preScripted',
                                                                  'addArgs',
                                                                  'addOpFunArgs',
                                                                  'addTrigFunArgs',
                                                                  'maybeArgs',
                                                                  'doubtArgs',
                                                                  'NUMBER',
                                                                  'addScripts',
                                                                  'VERTBAR',
                                                                  'Expression'
                                                                ],
                                                     'name' => 'aBarearg',
                                                     'prods' => [
                                                                  bless( {
                                                                           'patcount' => 0,
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'subrule' => 'preScripted',
                                                                                                 'matchrule' => 0,
                                                                                                 'argcode' => '[\'FUNCTION\']',
                                                                                                 'implicit' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 314
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'line' => 314,
                                                                                                 'lookahead' => 0,
                                                                                                 'argcode' => '[$item[1]]',
                                                                                                 'implicit' => undef,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'addArgs'
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'number' => 0,
                                                                           'uncommit' => undef,
                                                                           'line' => undef,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'argcode' => '[\'OPFUNCTION\']',
                                                                                                 'implicit' => undef,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'preScripted',
                                                                                                 'line' => 315,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'line' => 315,
                                                                                                 'lookahead' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]',
                                                                                                 'subrule' => 'addOpFunArgs',
                                                                                                 'matchrule' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'patcount' => 0,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0,
                                                                           'line' => 315,
                                                                           'uncommit' => undef,
                                                                           'number' => 1
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'argcode' => '[\'TRIGFUNCTION\']',
                                                                                                 'implicit' => undef,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'preScripted',
                                                                                                 'line' => 316,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 316,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'addTrigFunArgs',
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]'
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 0,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0,
                                                                           'line' => 316,
                                                                           'uncommit' => undef,
                                                                           'number' => 2
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[\'ATOM_OR_ID\']',
                                                                                                 'subrule' => 'preScripted',
                                                                                                 'matchrule' => 0,
                                                                                                 'line' => 317,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'line' => 317,
                                                                                                 'lookahead' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]',
                                                                                                 'subrule' => 'maybeArgs',
                                                                                                 'matchrule' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'number' => 3,
                                                                           'uncommit' => undef,
                                                                           'line' => 317
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'actcount' => 0,
                                                                           'strcount' => 0,
                                                                           'number' => 4,
                                                                           'uncommit' => undef,
                                                                           'line' => 318,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'argcode' => '[\'UNKNOWN\']',
                                                                                                 'implicit' => undef,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'preScripted',
                                                                                                 'line' => 318,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 318,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'doubtArgs',
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]'
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'patcount' => 0,
                                                                           'error' => undef,
                                                                           'dircount' => 0
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'number' => 5,
                                                                           'line' => 319,
                                                                           'uncommit' => undef,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0,
                                                                           'patcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'NUMBER',
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 319
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 319,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'addScripts',
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => '[$item[1]]'
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ]
                                                                         }, 'Parse::RecDescent::Production' ),
                                                                  bless( {
                                                                           'patcount' => 0,
                                                                           'error' => undef,
                                                                           'dircount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'VERTBAR',
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef,
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 320
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'argcode' => undef,
                                                                                                 'implicit' => undef,
                                                                                                 'subrule' => 'Expression',
                                                                                                 'matchrule' => 0,
                                                                                                 'line' => 320,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 320,
                                                                                                 'subrule' => 'VERTBAR',
                                                                                                 'matchrule' => 0,
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' ),
                                                                                        bless( {
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 320,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'addScripts',
                                                                                                 'argcode' => '[Fence($item[1],$item[2],$item[3])]',
                                                                                                 'implicit' => undef
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ],
                                                                           'number' => 6,
                                                                           'line' => 320,
                                                                           'uncommit' => undef,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'impcount' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'ketExpression' => bless( {
                                                          'opcount' => 0,
                                                          'calls' => [
                                                                       'Formulae',
                                                                       'METARELOP',
                                                                       'ARROW',
                                                                       'AddOp',
                                                                       'MulOp',
                                                                       'MODIFIEROP'
                                                                     ],
                                                          'prods' => [
                                                                       bless( {
                                                                                'error' => undef,
                                                                                'dircount' => 1,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'hashname' => '__DIRECTIVE1__',
                                                                                                      'name' => '<rulevar: local $forbidVertBar = 1>',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 389
                                                                                                    }, 'Parse::RecDescent::UncondReject' )
                                                                                           ],
                                                                                'line' => undef,
                                                                                'uncommit' => undef,
                                                                                'number' => 0,
                                                                                'strcount' => 0,
                                                                                'actcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'patcount' => 0,
                                                                                'error' => undef,
                                                                                'dircount' => 1,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 390,
                                                                                                      'hashname' => '__DIRECTIVE1__',
                                                                                                      'name' => '<rulevar: local $forbidLRAngle = 1>'
                                                                                                    }, 'Parse::RecDescent::UncondReject' )
                                                                                           ],
                                                                                'number' => 1,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'Formulae',
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 391
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'number' => 2
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'strcount' => 0,
                                                                                'actcount' => 0,
                                                                                'number' => 3,
                                                                                'line' => 392,
                                                                                'uncommit' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 392,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'METARELOP'
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'patcount' => 0,
                                                                                'error' => undef,
                                                                                'dircount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'error' => undef,
                                                                                'dircount' => 0,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 392,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'ARROW',
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'line' => 392,
                                                                                'uncommit' => undef,
                                                                                'number' => 4,
                                                                                'strcount' => 0,
                                                                                'actcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'number' => 5,
                                                                                'uncommit' => undef,
                                                                                'line' => 392,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0,
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'subrule' => 'AddOp',
                                                                                                      'matchrule' => 0,
                                                                                                      'line' => 392,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'strcount' => 0,
                                                                                'actcount' => 0,
                                                                                'line' => 392,
                                                                                'uncommit' => undef,
                                                                                'number' => 6,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 392,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'MulOp'
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'error' => undef,
                                                                                'dircount' => 0,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'subrule' => 'MODIFIEROP',
                                                                                                      'matchrule' => 0,
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 392
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'uncommit' => undef,
                                                                                'line' => 392,
                                                                                'number' => 7,
                                                                                'actcount' => 0,
                                                                                'strcount' => 0
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'name' => 'ketExpression',
                                                          'impcount' => 0,
                                                          'line' => 388,
                                                          'vars' => ' local $forbidVertBar = 1;
 local $forbidLRAngle = 1;
',
                                                          'changed' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'AnyOp' => bless( {
                                                  'impcount' => 0,
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 661,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'relop'
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'line' => undef,
                                                                        'uncommit' => undef,
                                                                        'number' => 0
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'number' => 1,
                                                                        'uncommit' => undef,
                                                                        'line' => 661,
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'patcount' => 0,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 661,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'METARELOP',
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'subrule' => 'ARROW',
                                                                                              'matchrule' => 0,
                                                                                              'line' => 661,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'patcount' => 0,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'number' => 2,
                                                                        'line' => 661,
                                                                        'uncommit' => undef
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'patcount' => 0,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 661,
                                                                                              'subrule' => 'AddOp',
                                                                                              'matchrule' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'number' => 3,
                                                                        'line' => 661,
                                                                        'uncommit' => undef,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'line' => 661,
                                                                        'uncommit' => undef,
                                                                        'number' => 4,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'subrule' => 'MulOp',
                                                                                              'matchrule' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'line' => 661
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'number' => 5,
                                                                        'uncommit' => undef,
                                                                        'line' => 661,
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 661,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'subrule' => 'MODIFIEROP',
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'line' => 662,
                                                                        'uncommit' => undef,
                                                                        'number' => 6,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'patcount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 662,
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => '[\'bigop\']',
                                                                                              'implicit' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'preScripted'
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'number' => 7,
                                                                        'line' => 663,
                                                                        'uncommit' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'subrule' => 'OPERATOR',
                                                                                              'matchrule' => 0,
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'line' => 663
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'addScripts',
                                                                                              'argcode' => '[$item[1]]',
                                                                                              'implicit' => undef,
                                                                                              'lookahead' => 0,
                                                                                              'line' => 663
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'AnyOp',
                                                  'calls' => [
                                                               'relop',
                                                               'METARELOP',
                                                               'ARROW',
                                                               'AddOp',
                                                               'MulOp',
                                                               'MODIFIEROP',
                                                               'preScripted',
                                                               'OPERATOR',
                                                               'addScripts'
                                                             ],
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'line' => 660,
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'addExpressionModifier' => bless( {
                                                                  'impcount' => 0,
                                                                  'name' => 'addExpressionModifier',
                                                                  'prods' => [
                                                                               bless( {
                                                                                        'strcount' => 0,
                                                                                        'actcount' => 1,
                                                                                        'number' => 0,
                                                                                        'line' => undef,
                                                                                        'uncommit' => undef,
                                                                                        'items' => [
                                                                                                     bless( {
                                                                                                              'hashname' => '__PATTERN1__',
                                                                                                              'pattern' => '^\\Z',
                                                                                                              'ldelim' => '/',
                                                                                                              'rdelim' => '/',
                                                                                                              'mod' => '',
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 220,
                                                                                                              'description' => '/^\\\\Z/'
                                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                                     bless( {
                                                                                                              'hashname' => '__ACTION1__',
                                                                                                              'code' => '{ $arg[0];}',
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 220
                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                   ],
                                                                                        'patcount' => 1,
                                                                                        'dircount' => 0,
                                                                                        'error' => undef
                                                                                      }, 'Parse::RecDescent::Production' ),
                                                                               bless( {
                                                                                        'items' => [
                                                                                                     bless( {
                                                                                                              'line' => 221,
                                                                                                              'lookahead' => 0,
                                                                                                              'repspec' => '?',
                                                                                                              'expected' => undef,
                                                                                                              'subrule' => 'PUNCT',
                                                                                                              'matchrule' => 0,
                                                                                                              'min' => 0,
                                                                                                              'argcode' => undef,
                                                                                                              'max' => 1
                                                                                                            }, 'Parse::RecDescent::Repetition' ),
                                                                                                     bless( {
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 221,
                                                                                                              'subrule' => 'OPEN',
                                                                                                              'matchrule' => 0,
                                                                                                              'argcode' => undef,
                                                                                                              'implicit' => undef
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 221,
                                                                                                              'subrule' => 'relop',
                                                                                                              'matchrule' => 0,
                                                                                                              'argcode' => undef,
                                                                                                              'implicit' => undef
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'implicit' => undef,
                                                                                                              'argcode' => undef,
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'Expression',
                                                                                                              'line' => 221,
                                                                                                              'lookahead' => 0
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'implicit' => undef,
                                                                                                              'argcode' => '[$item[2]]',
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'balancedClose',
                                                                                                              'line' => 221,
                                                                                                              'lookahead' => 0
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'code' => '{ Apply(New(\'annotated\'),$arg[0],
                    Fence($item[2], Apply($item[3],Absent(),$item[4]),$item[5])); }',
                                                                                                              'hashname' => '__ACTION1__',
                                                                                                              'line' => 222,
                                                                                                              'lookahead' => 0
                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                   ],
                                                                                        'dircount' => 0,
                                                                                        'error' => undef,
                                                                                        'patcount' => 0,
                                                                                        'strcount' => 0,
                                                                                        'actcount' => 1,
                                                                                        'line' => 220,
                                                                                        'uncommit' => undef,
                                                                                        'number' => 1
                                                                                      }, 'Parse::RecDescent::Production' ),
                                                                               bless( {
                                                                                        'error' => undef,
                                                                                        'dircount' => 0,
                                                                                        'patcount' => 0,
                                                                                        'items' => [
                                                                                                     bless( {
                                                                                                              'min' => 0,
                                                                                                              'argcode' => undef,
                                                                                                              'max' => 1,
                                                                                                              'line' => 229,
                                                                                                              'lookahead' => 0,
                                                                                                              'repspec' => '?',
                                                                                                              'expected' => undef,
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'PUNCT'
                                                                                                            }, 'Parse::RecDescent::Repetition' ),
                                                                                                     bless( {
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'OPEN',
                                                                                                              'implicit' => undef,
                                                                                                              'argcode' => undef,
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 229
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'MODIFIEROP',
                                                                                                              'argcode' => undef,
                                                                                                              'implicit' => undef,
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 229
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'subrule' => 'Expression',
                                                                                                              'matchrule' => 0,
                                                                                                              'argcode' => undef,
                                                                                                              'implicit' => undef,
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 229
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'argcode' => '[$item[2]]',
                                                                                                              'implicit' => undef,
                                                                                                              'subrule' => 'balancedClose',
                                                                                                              'matchrule' => 0,
                                                                                                              'line' => 229,
                                                                                                              'lookahead' => 0
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'hashname' => '__ACTION1__',
                                                                                                              'code' => '{ Apply($item[3],$arg[0],$item[4]); }',
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 230
                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                   ],
                                                                                        'uncommit' => undef,
                                                                                        'line' => 228,
                                                                                        'number' => 2,
                                                                                        'actcount' => 1,
                                                                                        'strcount' => 0
                                                                                      }, 'Parse::RecDescent::Production' ),
                                                                               bless( {
                                                                                        'items' => [
                                                                                                     bless( {
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 231,
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'MODIFIER',
                                                                                                              'implicit' => undef,
                                                                                                              'argcode' => undef
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'code' => '{ Apply(New(\'annotated\'),$arg[0],$item[1]); }',
                                                                                                              'hashname' => '__ACTION1__',
                                                                                                              'line' => 232,
                                                                                                              'lookahead' => 0
                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                   ],
                                                                                        'patcount' => 0,
                                                                                        'error' => undef,
                                                                                        'dircount' => 0,
                                                                                        'strcount' => 0,
                                                                                        'actcount' => 1,
                                                                                        'number' => 3,
                                                                                        'line' => 230,
                                                                                        'uncommit' => undef
                                                                                      }, 'Parse::RecDescent::Production' ),
                                                                               bless( {
                                                                                        'strcount' => 0,
                                                                                        'actcount' => 1,
                                                                                        'line' => 233,
                                                                                        'uncommit' => undef,
                                                                                        'number' => 4,
                                                                                        'items' => [
                                                                                                     bless( {
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 233,
                                                                                                              'subrule' => 'MODIFIEROP',
                                                                                                              'matchrule' => 0,
                                                                                                              'implicit' => undef,
                                                                                                              'argcode' => undef
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 233,
                                                                                                              'matchrule' => 0,
                                                                                                              'subrule' => 'Expression',
                                                                                                              'implicit' => undef,
                                                                                                              'argcode' => undef
                                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                                     bless( {
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 234,
                                                                                                              'hashname' => '__ACTION1__',
                                                                                                              'code' => '{ Apply($item[1],$arg[0],$item[2]); }'
                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                   ],
                                                                                        'error' => undef,
                                                                                        'dircount' => 0,
                                                                                        'patcount' => 0
                                                                                      }, 'Parse::RecDescent::Production' ),
                                                                               bless( {
                                                                                        'actcount' => 1,
                                                                                        'strcount' => 0,
                                                                                        'number' => 5,
                                                                                        'uncommit' => undef,
                                                                                        'line' => 235,
                                                                                        'items' => [
                                                                                                     bless( {
                                                                                                              'hashname' => '__ACTION1__',
                                                                                                              'code' => '{ $arg[0]; }',
                                                                                                              'lookahead' => 0,
                                                                                                              'line' => 235
                                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                                   ],
                                                                                        'patcount' => 0,
                                                                                        'dircount' => 0,
                                                                                        'error' => undef
                                                                                      }, 'Parse::RecDescent::Production' )
                                                                             ],
                                                                  'calls' => [
                                                                               'PUNCT',
                                                                               'OPEN',
                                                                               'relop',
                                                                               'Expression',
                                                                               'balancedClose',
                                                                               'MODIFIEROP',
                                                                               'MODIFIER'
                                                                             ],
                                                                  'changed' => 0,
                                                                  'vars' => '',
                                                                  'line' => 218,
                                                                  'opcount' => 0
                                                                }, 'Parse::RecDescent::Rule' ),
                              'ARROW' => bless( {
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'line' => 761,
                                                  'impcount' => 0,
                                                  'name' => 'ARROW',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'line' => 761,
                                                                                              'description' => '/ARROW:\\\\S*:\\\\d+/',
                                                                                              'pattern' => 'ARROW:\\S*:\\d+',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 761
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 1,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'calls' => [],
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'MulOp' => bless( {
                                                  'calls' => [
                                                               'BINOP',
                                                               'addOpDecoration',
                                                               'MULOP'
                                                             ],
                                                  'name' => 'MulOp',
                                                  'prods' => [
                                                               bless( {
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 670,
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef,
                                                                                              'subrule' => 'BINOP',
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'line' => 670,
                                                                                              'lookahead' => 0,
                                                                                              'argcode' => '[$item[1]]',
                                                                                              'implicit' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'addOpDecoration'
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 671,
                                                                                              'subrule' => 'MULOP',
                                                                                              'matchrule' => 0,
                                                                                              'argcode' => undef,
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 671,
                                                                                              'subrule' => 'addOpDecoration',
                                                                                              'matchrule' => 0,
                                                                                              'implicit' => undef,
                                                                                              'argcode' => '[$item[1]]'
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'patcount' => 0,
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'line' => 671,
                                                                        'uncommit' => undef,
                                                                        'number' => 1
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'impcount' => 0,
                                                  'line' => 670,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'MODIFIER' => bless( {
                                                     'opcount' => 0,
                                                     'impcount' => 0,
                                                     'calls' => [],
                                                     'prods' => [
                                                                  bless( {
                                                                           'patcount' => 1,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'hashname' => '__PATTERN1__',
                                                                                                 'lookahead' => 0,
                                                                                                 'mod' => '',
                                                                                                 'description' => '/MODIFIER:\\\\S*:\\\\d+/',
                                                                                                 'line' => 760,
                                                                                                 'pattern' => 'MODIFIER:\\S*:\\d+',
                                                                                                 'ldelim' => '/',
                                                                                                 'rdelim' => '/'
                                                                                               }, 'Parse::RecDescent::Token' ),
                                                                                        bless( {
                                                                                                 'hashname' => '__ACTION1__',
                                                                                                 'code' => '{ Lookup($item[1]); }',
                                                                                                 'lookahead' => 0,
                                                                                                 'line' => 760
                                                                                               }, 'Parse::RecDescent::Action' )
                                                                                      ],
                                                                           'number' => 0,
                                                                           'line' => undef,
                                                                           'uncommit' => undef,
                                                                           'strcount' => 0,
                                                                           'actcount' => 1
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'name' => 'MODIFIER',
                                                     'vars' => '',
                                                     'changed' => 0,
                                                     'line' => 760
                                                   }, 'Parse::RecDescent::Rule' ),
                              'SignedTerm' => bless( {
                                                       'calls' => [
                                                                    'AddOp',
                                                                    'Term'
                                                                  ],
                                                       'prods' => [
                                                                    bless( {
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'subrule' => 'AddOp',
                                                                                                   'matchrule' => 0,
                                                                                                   'line' => 243,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 243,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'Term'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 243,
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ Apply($item[1],$item[2]); }'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'number' => 0,
                                                                             'line' => undef,
                                                                             'uncommit' => undef,
                                                                             'strcount' => 0,
                                                                             'actcount' => 1
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 244,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'subrule' => 'Term',
                                                                                                   'matchrule' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0,
                                                                             'strcount' => 0,
                                                                             'actcount' => 0,
                                                                             'line' => 244,
                                                                             'uncommit' => undef,
                                                                             'number' => 1
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'SignedTerm',
                                                       'impcount' => 0,
                                                       'line' => 241,
                                                       'vars' => '',
                                                       'changed' => 0,
                                                       'opcount' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'PUNCT' => bless( {
                                                  'opcount' => 0,
                                                  'line' => 746,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'calls' => [],
                                                  'name' => 'PUNCT',
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'line' => 746,
                                                                                              'description' => '/PUNCT:\\\\S*:\\\\d+/',
                                                                                              'mod' => '',
                                                                                              'lookahead' => 0,
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => 'PUNCT:\\S*:\\d+'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 746,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'impcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'addEasyArgs' => bless( {
                                                        'line' => 553,
                                                        'changed' => 0,
                                                        'vars' => '',
                                                        'name' => 'addEasyArgs',
                                                        'prods' => [
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'subrule' => 'COMPOSEOP',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 555
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 555,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'makeComposition',
                                                                                                    'argcode' => '[$arg[0],$item[1]]',
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => 556,
                                                                              'number' => 1,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'APPLYOP',
                                                                                                    'repspec' => '?',
                                                                                                    'expected' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 556,
                                                                                                    'max' => 1,
                                                                                                    'argcode' => undef,
                                                                                                    'min' => 0
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
                                                                                           bless( {
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'subrule' => 'OPEN',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 556,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'Argument',
                                                                                                    'line' => 556,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 557,
                                                                                                    'lookahead' => 0,
                                                                                                    'repspec' => 's?',
                                                                                                    'expected' => 'argPunct',
                                                                                                    'subrule' => '_alternation_1_of_production_2_of_rule_addEasyArgs',
                                                                                                    'matchrule' => 0,
                                                                                                    'min' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'max' => 100000000
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 558,
                                                                                                    'subrule' => 'balancedClose',
                                                                                                    'matchrule' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[$item[2]]'
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 559,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ ApplyDelimited($arg[0],$item[2],$item[3],
                                   map(@$_,@{$item[4]}),$item[5]); }',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'calls' => [
                                                                     'COMPOSEOP',
                                                                     'makeComposition',
                                                                     'APPLYOP',
                                                                     'OPEN',
                                                                     'Argument',
                                                                     '_alternation_1_of_production_2_of_rule_addEasyArgs',
                                                                     'balancedClose'
                                                                   ],
                                                        'impcount' => 1,
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              'requireArgs' => bless( {
                                                        'name' => 'requireArgs',
                                                        'prods' => [
                                                                     bless( {
                                                                              'number' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 516,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'OPEN',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'subrule' => 'Argument',
                                                                                                    'matchrule' => 0,
                                                                                                    'line' => 516,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'min' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'max' => 100000000,
                                                                                                    'line' => 516,
                                                                                                    'lookahead' => 0,
                                                                                                    'repspec' => 's?',
                                                                                                    'expected' => 'argPunct',
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => '_alternation_1_of_production_1_of_rule_requireArgs'
                                                                                                  }, 'Parse::RecDescent::Repetition' ),
                                                                                           bless( {
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'balancedClose',
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[$item[1]]',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 517
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 518,
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ ApplyDelimited($arg[0],$item[1],$item[2],
                                   map(@$_,@{$item[3]}),$item[4]); }'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'subrule' => 'barearg',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef,
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 521
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'code' => '{ Apply($arg[0],$item[1]); }',
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'line' => 521,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'number' => 1,
                                                                              'uncommit' => undef,
                                                                              'line' => 520
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'calls' => [
                                                                     'OPEN',
                                                                     'Argument',
                                                                     '_alternation_1_of_production_1_of_rule_requireArgs',
                                                                     'balancedClose',
                                                                     'barearg'
                                                                   ],
                                                        'impcount' => 0,
                                                        'line' => 514,
                                                        'changed' => 0,
                                                        'vars' => '',
                                                        'opcount' => 0
                                                      }, 'Parse::RecDescent::Rule' ),
                              'addScripts' => bless( {
                                                       'opcount' => 0,
                                                       'impcount' => 0,
                                                       'calls' => [
                                                                    'POSTSUPERSCRIPT',
                                                                    'addScripts',
                                                                    'POSTSUBSCRIPT',
                                                                    'POSTFIX'
                                                                  ],
                                                       'name' => 'addScripts',
                                                       'prods' => [
                                                                    bless( {
                                                                             'number' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'patcount' => 1,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'hashname' => '__PATTERN1__',
                                                                                                   'ldelim' => '/',
                                                                                                   'rdelim' => '/',
                                                                                                   'pattern' => '^\\Z',
                                                                                                   'line' => 408,
                                                                                                   'description' => '/^\\\\Z/',
                                                                                                   'mod' => '',
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Token' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 408,
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ $arg[0];}'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ]
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'number' => 1,
                                                                             'uncommit' => undef,
                                                                             'line' => 408,
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'POSTSUPERSCRIPT',
                                                                                                   'line' => 409,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 409,
                                                                                                   'lookahead' => 0,
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[NewScript($arg[0],$item[1])]',
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'matchrule' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ]
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 410,
                                                                                                   'subrule' => 'POSTSUBSCRIPT',
                                                                                                   'matchrule' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 410,
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'matchrule' => 0,
                                                                                                   'argcode' => '[NewScript($arg[0],$item[1])]',
                                                                                                   'implicit' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'strcount' => 0,
                                                                             'actcount' => 0,
                                                                             'number' => 2,
                                                                             'line' => 410,
                                                                             'uncommit' => undef
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'number' => 3,
                                                                             'uncommit' => undef,
                                                                             'line' => 411,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 411,
                                                                                                   'lookahead' => 0,
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'POSTFIX'
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => '[Apply($item[1],$arg[0])]',
                                                                                                   'subrule' => 'addScripts',
                                                                                                   'matchrule' => 0,
                                                                                                   'line' => 411,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'number' => 4,
                                                                             'uncommit' => undef,
                                                                             'line' => 412,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 412,
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'code' => '{ $arg[0]; }'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'vars' => '',
                                                       'changed' => 0,
                                                       'line' => 406
                                                     }, 'Parse::RecDescent::Rule' ),
                              'Formula' => bless( {
                                                    'opcount' => 0,
                                                    'calls' => [
                                                                 'Expression',
                                                                 'extendFormula'
                                                               ],
                                                    'prods' => [
                                                                 bless( {
                                                                          'actcount' => 0,
                                                                          'strcount' => 0,
                                                                          'uncommit' => undef,
                                                                          'line' => undef,
                                                                          'number' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'subrule' => 'Expression',
                                                                                                'matchrule' => 0,
                                                                                                'argcode' => undef,
                                                                                                'implicit' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'line' => 130
                                                                                              }, 'Parse::RecDescent::Subrule' ),
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 130,
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'extendFormula',
                                                                                                'implicit' => undef,
                                                                                                'argcode' => '[$item[1]]'
                                                                                              }, 'Parse::RecDescent::Subrule' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 0
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'name' => 'Formula',
                                                    'impcount' => 0,
                                                    'line' => 130,
                                                    'vars' => '',
                                                    'changed' => 0
                                                  }, 'Parse::RecDescent::Rule' ),
                              'addOpArgs' => bless( {
                                                      'opcount' => 0,
                                                      'changed' => 0,
                                                      'vars' => '',
                                                      'line' => 587,
                                                      'impcount' => 0,
                                                      'name' => 'addOpArgs',
                                                      'prods' => [
                                                                   bless( {
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 1,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__PATTERN1__',
                                                                                                  'pattern' => '^\\Z',
                                                                                                  'rdelim' => '/',
                                                                                                  'ldelim' => '/',
                                                                                                  'mod' => '',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 589,
                                                                                                  'description' => '/^\\\\Z/'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ $arg[0];}',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 589
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'number' => 0,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'min' => 0,
                                                                                                  'max' => 1,
                                                                                                  'argcode' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 591,
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'APPLYOP',
                                                                                                  'repspec' => '?',
                                                                                                  'expected' => undef
                                                                                                }, 'Parse::RecDescent::Repetition' ),
                                                                                         bless( {
                                                                                                  'line' => 591,
                                                                                                  'lookahead' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef,
                                                                                                  'matchrule' => 0,
                                                                                                  'subrule' => 'Factor'
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 591,
                                                                                                  'subrule' => 'moreOpArgFactors',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => '[$item[2]]'
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 591,
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ Apply($arg[0],$item[3]);}'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'uncommit' => undef,
                                                                            'line' => 590,
                                                                            'number' => 1,
                                                                            'actcount' => 1,
                                                                            'strcount' => 0
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'number' => 2,
                                                                            'line' => 592,
                                                                            'uncommit' => undef,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'patcount' => 0,
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ $arg[0]; }',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 592
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ]
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'calls' => [
                                                                   'APPLYOP',
                                                                   'Factor',
                                                                   'moreOpArgFactors'
                                                                 ]
                                                    }, 'Parse::RecDescent::Rule' ),
                              'metarelopFormula' => bless( {
                                                             'opcount' => 0,
                                                             'impcount' => 0,
                                                             'name' => 'metarelopFormula',
                                                             'prods' => [
                                                                          bless( {
                                                                                   'number' => 0,
                                                                                   'line' => undef,
                                                                                   'uncommit' => undef,
                                                                                   'strcount' => 0,
                                                                                   'actcount' => 1,
                                                                                   'patcount' => 0,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'METARELOP',
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 181
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'subrule' => 'Formula',
                                                                                                         'matchrule' => 0,
                                                                                                         'implicit' => undef,
                                                                                                         'argcode' => undef,
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 181
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'hashname' => '__ACTION1__',
                                                                                                         'code' => '{ [$item[1],$item[2]]; }',
                                                                                                         'lookahead' => 0,
                                                                                                         'line' => 181
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ]
                                                                                 }, 'Parse::RecDescent::Production' ),
                                                                          bless( {
                                                                                   'line' => 182,
                                                                                   'uncommit' => undef,
                                                                                   'number' => 1,
                                                                                   'strcount' => 0,
                                                                                   'actcount' => 1,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'patcount' => 1,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'argcode' => undef,
                                                                                                         'implicit' => undef,
                                                                                                         'matchrule' => 0,
                                                                                                         'subrule' => 'METARELOP',
                                                                                                         'line' => 182,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Subrule' ),
                                                                                                bless( {
                                                                                                         'hashname' => '__PATTERN1__',
                                                                                                         'line' => 182,
                                                                                                         'description' => '/^\\\\Z/',
                                                                                                         'mod' => '',
                                                                                                         'lookahead' => 0,
                                                                                                         'rdelim' => '/',
                                                                                                         'ldelim' => '/',
                                                                                                         'pattern' => '^\\Z'
                                                                                                       }, 'Parse::RecDescent::Token' ),
                                                                                                bless( {
                                                                                                         'code' => '{ [$item[1], Absent()]; }',
                                                                                                         'hashname' => '__ACTION1__',
                                                                                                         'line' => 182,
                                                                                                         'lookahead' => 0
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ]
                                                                                 }, 'Parse::RecDescent::Production' )
                                                                        ],
                                                             'calls' => [
                                                                          'METARELOP',
                                                                          'Formula'
                                                                        ],
                                                             'changed' => 0,
                                                             'vars' => '',
                                                             'line' => 180
                                                           }, 'Parse::RecDescent::Rule' ),
                              'moreIntOpArgFactors' => bless( {
                                                                'impcount' => 0,
                                                                'name' => 'moreIntOpArgFactors',
                                                                'prods' => [
                                                                             bless( {
                                                                                      'dircount' => 0,
                                                                                      'error' => undef,
                                                                                      'patcount' => 1,
                                                                                      'items' => [
                                                                                                   bless( {
                                                                                                            'hashname' => '__PATTERN1__',
                                                                                                            'rdelim' => '/',
                                                                                                            'ldelim' => '/',
                                                                                                            'pattern' => '^\\Z',
                                                                                                            'description' => '/^\\\\Z/',
                                                                                                            'line' => 618,
                                                                                                            'mod' => '',
                                                                                                            'lookahead' => 0
                                                                                                          }, 'Parse::RecDescent::Token' ),
                                                                                                   bless( {
                                                                                                            'hashname' => '__ACTION1__',
                                                                                                            'code' => '{ $arg[0];}',
                                                                                                            'lookahead' => 0,
                                                                                                            'line' => 618
                                                                                                          }, 'Parse::RecDescent::Action' )
                                                                                                 ],
                                                                                      'uncommit' => undef,
                                                                                      'line' => undef,
                                                                                      'number' => 0,
                                                                                      'actcount' => 1,
                                                                                      'strcount' => 0
                                                                                    }, 'Parse::RecDescent::Production' ),
                                                                             bless( {
                                                                                      'items' => [
                                                                                                   bless( {
                                                                                                            'matchrule' => 0,
                                                                                                            'subrule' => 'MulOp',
                                                                                                            'argcode' => undef,
                                                                                                            'implicit' => undef,
                                                                                                            'lookahead' => 0,
                                                                                                            'line' => 619
                                                                                                          }, 'Parse::RecDescent::Subrule' ),
                                                                                                   bless( {
                                                                                                            'implicit' => undef,
                                                                                                            'argcode' => undef,
                                                                                                            'subrule' => 'IntFactor',
                                                                                                            'matchrule' => 0,
                                                                                                            'line' => 619,
                                                                                                            'lookahead' => 0
                                                                                                          }, 'Parse::RecDescent::Subrule' ),
                                                                                                   bless( {
                                                                                                            'implicit' => undef,
                                                                                                            'argcode' => '[ApplyNary($item[1],$arg[0],$item[2])]',
                                                                                                            'subrule' => 'moreIntOpArgFactors',
                                                                                                            'matchrule' => 0,
                                                                                                            'line' => 619,
                                                                                                            'lookahead' => 0
                                                                                                          }, 'Parse::RecDescent::Subrule' )
                                                                                                 ],
                                                                                      'patcount' => 0,
                                                                                      'dircount' => 0,
                                                                                      'error' => undef,
                                                                                      'actcount' => 0,
                                                                                      'strcount' => 0,
                                                                                      'number' => 1,
                                                                                      'uncommit' => undef,
                                                                                      'line' => 618
                                                                                    }, 'Parse::RecDescent::Production' ),
                                                                             bless( {
                                                                                      'actcount' => 0,
                                                                                      'strcount' => 0,
                                                                                      'number' => 2,
                                                                                      'uncommit' => undef,
                                                                                      'line' => 620,
                                                                                      'items' => [
                                                                                                   bless( {
                                                                                                            'line' => 620,
                                                                                                            'lookahead' => 0,
                                                                                                            'argcode' => undef,
                                                                                                            'implicit' => undef,
                                                                                                            'subrule' => 'IntFactor',
                                                                                                            'matchrule' => 0
                                                                                                          }, 'Parse::RecDescent::Subrule' ),
                                                                                                   bless( {
                                                                                                            'subrule' => 'moreIntOpArgFactors',
                                                                                                            'matchrule' => 0,
                                                                                                            'implicit' => undef,
                                                                                                            'argcode' => '[ApplyNary(InvisibleTimes(),$arg[0],$item[1])]',
                                                                                                            'lookahead' => 0,
                                                                                                            'line' => 620
                                                                                                          }, 'Parse::RecDescent::Subrule' )
                                                                                                 ],
                                                                                      'patcount' => 0,
                                                                                      'dircount' => 0,
                                                                                      'error' => undef
                                                                                    }, 'Parse::RecDescent::Production' ),
                                                                             bless( {
                                                                                      'line' => 621,
                                                                                      'uncommit' => undef,
                                                                                      'number' => 3,
                                                                                      'strcount' => 0,
                                                                                      'actcount' => 1,
                                                                                      'dircount' => 0,
                                                                                      'error' => undef,
                                                                                      'patcount' => 0,
                                                                                      'items' => [
                                                                                                   bless( {
                                                                                                            'hashname' => '__ACTION1__',
                                                                                                            'code' => '{ $arg[0]; }',
                                                                                                            'lookahead' => 0,
                                                                                                            'line' => 621
                                                                                                          }, 'Parse::RecDescent::Action' )
                                                                                                 ]
                                                                                    }, 'Parse::RecDescent::Production' )
                                                                           ],
                                                                'calls' => [
                                                                             'MulOp',
                                                                             'IntFactor',
                                                                             'moreIntOpArgFactors'
                                                                           ],
                                                                'changed' => 0,
                                                                'vars' => '',
                                                                'line' => 616,
                                                                'opcount' => 0
                                                              }, 'Parse::RecDescent::Rule' ),
                              'barearg' => bless( {
                                                    'opcount' => 0,
                                                    'impcount' => 0,
                                                    'calls' => [
                                                                 'aBarearg',
                                                                 'moreBareargs'
                                                               ],
                                                    'name' => 'barearg',
                                                    'prods' => [
                                                                 bless( {
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'implicit' => undef,
                                                                                                'argcode' => undef,
                                                                                                'subrule' => 'aBarearg',
                                                                                                'matchrule' => 0,
                                                                                                'line' => 312,
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::Subrule' ),
                                                                                       bless( {
                                                                                                'subrule' => 'moreBareargs',
                                                                                                'matchrule' => 0,
                                                                                                'argcode' => '[$item[1]]',
                                                                                                'implicit' => undef,
                                                                                                'lookahead' => 0,
                                                                                                'line' => 312
                                                                                              }, 'Parse::RecDescent::Subrule' )
                                                                                     ],
                                                                          'patcount' => 0,
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'strcount' => 0,
                                                                          'actcount' => 0,
                                                                          'number' => 0,
                                                                          'line' => undef,
                                                                          'uncommit' => undef
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'vars' => '',
                                                    'changed' => 0,
                                                    'line' => 311
                                                  }, 'Parse::RecDescent::Rule' ),
                              'factorOpenExpr' => bless( {
                                                           'opcount' => 0,
                                                           'calls' => [
                                                                        '_alternation_1_of_production_1_of_rule_factorOpenExpr',
                                                                        'CLOSE',
                                                                        'addScripts',
                                                                        'PUNCT',
                                                                        'AnyOp',
                                                                        'balancedClose'
                                                                      ],
                                                           'prods' => [
                                                                        bless( {
                                                                                 'number' => 0,
                                                                                 'line' => undef,
                                                                                 'uncommit' => undef,
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 0,
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'expected' => 'PUNCT',
                                                                                                       'repspec' => 's',
                                                                                                       'subrule' => '_alternation_1_of_production_1_of_rule_factorOpenExpr',
                                                                                                       'matchrule' => 0,
                                                                                                       'line' => 461,
                                                                                                       'lookahead' => 0,
                                                                                                       'argcode' => undef,
                                                                                                       'max' => 100000000,
                                                                                                       'min' => 1
                                                                                                     }, 'Parse::RecDescent::Repetition' ),
                                                                                              bless( {
                                                                                                       'argcode' => undef,
                                                                                                       'implicit' => undef,
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'CLOSE',
                                                                                                       'line' => 461,
                                                                                                       'lookahead' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'addScripts',
                                                                                                       'implicit' => undef,
                                                                                                       'argcode' => '[Fence($arg[0],$arg[1],map(@$_,@{$item[1]}),$item[2])]',
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 462
                                                                                                     }, 'Parse::RecDescent::Subrule' )
                                                                                            ]
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 0,
                                                                                 'number' => 1,
                                                                                 'line' => 463,
                                                                                 'uncommit' => undef,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'line' => 464,
                                                                                                       'lookahead' => 0,
                                                                                                       'implicit' => undef,
                                                                                                       'argcode' => undef,
                                                                                                       'subrule' => 'PUNCT',
                                                                                                       'matchrule' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'argcode' => undef,
                                                                                                       'implicit' => undef,
                                                                                                       'subrule' => 'AnyOp',
                                                                                                       'matchrule' => 0,
                                                                                                       'line' => 464,
                                                                                                       'lookahead' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'balancedClose',
                                                                                                       'implicit' => undef,
                                                                                                       'argcode' => '[$arg[0]]',
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 464
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'implicit' => undef,
                                                                                                       'argcode' => '[InterpretDelimited(New(\'group\'),
                                            $arg[0],$arg[1],$item[1],$item[2],$item[3])]',
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'addScripts',
                                                                                                       'line' => 465,
                                                                                                       'lookahead' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' )
                                                                                            ],
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'balancedClose',
                                                                                                       'argcode' => '[$arg[0]]',
                                                                                                       'implicit' => undef,
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 468
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'line' => 468,
                                                                                                       'lookahead' => 0,
                                                                                                       'argcode' => '[Fence($arg[0],$arg[1],$item[1])]',
                                                                                                       'implicit' => undef,
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'addScripts'
                                                                                                     }, 'Parse::RecDescent::Subrule' )
                                                                                            ],
                                                                                 'patcount' => 0,
                                                                                 'error' => undef,
                                                                                 'dircount' => 0,
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 0,
                                                                                 'number' => 2,
                                                                                 'line' => 467,
                                                                                 'uncommit' => undef
                                                                               }, 'Parse::RecDescent::Production' )
                                                                      ],
                                                           'name' => 'factorOpenExpr',
                                                           'impcount' => 0,
                                                           'line' => 458,
                                                           'vars' => '',
                                                           'changed' => 0
                                                         }, 'Parse::RecDescent::Rule' ),
                              'MIDDLE' => bless( {
                                                   'opcount' => 0,
                                                   'impcount' => 0,
                                                   'prods' => [
                                                                bless( {
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'hashname' => '__PATTERN1__',
                                                                                               'mod' => '',
                                                                                               'lookahead' => 0,
                                                                                               'line' => 775,
                                                                                               'description' => '/MIDDLE:\\\\S*:\\\\d+/',
                                                                                               'pattern' => 'MIDDLE:\\S*:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'line' => 775,
                                                                                               'lookahead' => 0
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'patcount' => 1,
                                                                         'error' => undef,
                                                                         'dircount' => 0,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0,
                                                                         'number' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => undef
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'name' => 'MIDDLE',
                                                   'calls' => [],
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 775
                                                 }, 'Parse::RecDescent::Rule' ),
                              'Subscript' => bless( {
                                                      'line' => 83,
                                                      'changed' => 0,
                                                      'vars' => ' local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH;
',
                                                      'prods' => [
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__DIRECTIVE1__',
                                                                                                  'name' => '<rulevar: local $MaxAbsDepth = $LaTeXML::MathParser::MAX_ABS_DEPTH>',
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 84
                                                                                                }, 'Parse::RecDescent::UncondReject' )
                                                                                       ],
                                                                            'patcount' => 0,
                                                                            'dircount' => 1,
                                                                            'error' => undef,
                                                                            'strcount' => 0,
                                                                            'actcount' => 0,
                                                                            'number' => 0,
                                                                            'line' => undef,
                                                                            'uncommit' => undef
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef,
                                                                                                  'subrule' => 'aSubscript',
                                                                                                  'matchrule' => 0,
                                                                                                  'line' => 86,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 86,
                                                                                                  'subrule' => '_alternation_1_of_production_2_of_rule_Subscript',
                                                                                                  'matchrule' => 0,
                                                                                                  'repspec' => 's?',
                                                                                                  'expected' => 'PUNCT',
                                                                                                  'min' => 0,
                                                                                                  'max' => 100000000,
                                                                                                  'argcode' => undef
                                                                                                }, 'Parse::RecDescent::Repetition' ),
                                                                                         bless( {
                                                                                                  'code' => '{ NewList($item[1],map(@$_,@{$item[2]})); }',
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'line' => 87,
                                                                                                  'lookahead' => 0
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'number' => 1
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'name' => 'Subscript',
                                                      'calls' => [
                                                                   'aSubscript',
                                                                   '_alternation_1_of_production_2_of_rule_Subscript'
                                                                 ],
                                                      'impcount' => 1,
                                                      'opcount' => 0
                                                    }, 'Parse::RecDescent::Rule' ),
                              'RELOP' => bless( {
                                                  'opcount' => 0,
                                                  'prods' => [
                                                               bless( {
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 1,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => 'RELOP:\\S*:\\d+',
                                                                                              'line' => 748,
                                                                                              'description' => '/RELOP:\\\\S*:\\\\d+/',
                                                                                              'mod' => '',
                                                                                              'lookahead' => 0,
                                                                                              'hashname' => '__PATTERN1__'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'line' => 748,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{ Lookup($item[1]); }',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'RELOP',
                                                  'calls' => [],
                                                  'impcount' => 0,
                                                  'line' => 748,
                                                  'changed' => 0,
                                                  'vars' => ''
                                                }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_1_of_rule_forbidArgs' => bless( {
                                                                                              'changed' => 0,
                                                                                              'vars' => '',
                                                                                              'line' => 791,
                                                                                              'impcount' => 0,
                                                                                              'prods' => [
                                                                                                           bless( {
                                                                                                                    'items' => [
                                                                                                                                 bless( {
                                                                                                                                          'line' => 791,
                                                                                                                                          'lookahead' => 0,
                                                                                                                                          'implicit' => undef,
                                                                                                                                          'argcode' => undef,
                                                                                                                                          'matchrule' => 0,
                                                                                                                                          'subrule' => 'argPunct'
                                                                                                                                        }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                 bless( {
                                                                                                                                          'line' => 791,
                                                                                                                                          'lookahead' => 0,
                                                                                                                                          'argcode' => undef,
                                                                                                                                          'implicit' => undef,
                                                                                                                                          'subrule' => 'Argument',
                                                                                                                                          'matchrule' => 0
                                                                                                                                        }, 'Parse::RecDescent::Subrule' )
                                                                                                                               ],
                                                                                                                    'dircount' => 0,
                                                                                                                    'error' => undef,
                                                                                                                    'patcount' => 0,
                                                                                                                    'strcount' => 0,
                                                                                                                    'actcount' => 0,
                                                                                                                    'line' => undef,
                                                                                                                    'uncommit' => undef,
                                                                                                                    'number' => 0
                                                                                                                  }, 'Parse::RecDescent::Production' )
                                                                                                         ],
                                                                                              'name' => '_alternation_1_of_production_1_of_rule_forbidArgs',
                                                                                              'calls' => [
                                                                                                           'argPunct',
                                                                                                           'Argument'
                                                                                                         ],
                                                                                              'opcount' => 0
                                                                                            }, 'Parse::RecDescent::Rule' ),
                              'ARRAY' => bless( {
                                                  'opcount' => 0,
                                                  'impcount' => 0,
                                                  'name' => 'ARRAY',
                                                  'prods' => [
                                                               bless( {
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'number' => 0,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 1,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'description' => '/ARRAY:\\\\S*:\\\\d+/',
                                                                                              'line' => 744,
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'rdelim' => '/',
                                                                                              'ldelim' => '/',
                                                                                              'pattern' => 'ARRAY:\\S*:\\d+'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 744,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'calls' => [],
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'line' => 744
                                                }, 'Parse::RecDescent::Rule' ),
                              'addTrigFunArgs' => bless( {
                                                           'opcount' => 0,
                                                           'impcount' => 0,
                                                           'calls' => [
                                                                        'addEasyArgs',
                                                                        'APPLYOP',
                                                                        'trigBarearg'
                                                                      ],
                                                           'prods' => [
                                                                        bless( {
                                                                                 'actcount' => 1,
                                                                                 'strcount' => 0,
                                                                                 'uncommit' => undef,
                                                                                 'line' => undef,
                                                                                 'number' => 0,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'line' => 546,
                                                                                                       'description' => '/^\\\\Z/',
                                                                                                       'lookahead' => 0,
                                                                                                       'mod' => '',
                                                                                                       'rdelim' => '/',
                                                                                                       'ldelim' => '/',
                                                                                                       'pattern' => '^\\Z',
                                                                                                       'hashname' => '__PATTERN1__'
                                                                                                     }, 'Parse::RecDescent::Token' ),
                                                                                              bless( {
                                                                                                       'hashname' => '__ACTION1__',
                                                                                                       'code' => '{ $arg[0];}',
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 546
                                                                                                     }, 'Parse::RecDescent::Action' )
                                                                                            ],
                                                                                 'dircount' => 0,
                                                                                 'error' => undef,
                                                                                 'patcount' => 1
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'actcount' => 0,
                                                                                 'strcount' => 0,
                                                                                 'number' => 1,
                                                                                 'uncommit' => undef,
                                                                                 'line' => 546,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 547,
                                                                                                       'subrule' => 'addEasyArgs',
                                                                                                       'matchrule' => 0,
                                                                                                       'implicit' => undef,
                                                                                                       'argcode' => '[$arg[0]]'
                                                                                                     }, 'Parse::RecDescent::Subrule' )
                                                                                            ],
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'actcount' => 1,
                                                                                 'strcount' => 0,
                                                                                 'number' => 2,
                                                                                 'uncommit' => undef,
                                                                                 'line' => 548,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'repspec' => '?',
                                                                                                       'expected' => undef,
                                                                                                       'matchrule' => 0,
                                                                                                       'subrule' => 'APPLYOP',
                                                                                                       'line' => 549,
                                                                                                       'lookahead' => 0,
                                                                                                       'argcode' => undef,
                                                                                                       'max' => 1,
                                                                                                       'min' => 0
                                                                                                     }, 'Parse::RecDescent::Repetition' ),
                                                                                              bless( {
                                                                                                       'line' => 549,
                                                                                                       'lookahead' => 0,
                                                                                                       'argcode' => undef,
                                                                                                       'implicit' => undef,
                                                                                                       'subrule' => 'trigBarearg',
                                                                                                       'matchrule' => 0
                                                                                                     }, 'Parse::RecDescent::Subrule' ),
                                                                                              bless( {
                                                                                                       'hashname' => '__ACTION1__',
                                                                                                       'code' => '{ Apply($arg[0],$item[2]);}',
                                                                                                       'lookahead' => 0,
                                                                                                       'line' => 549
                                                                                                     }, 'Parse::RecDescent::Action' )
                                                                                            ],
                                                                                 'patcount' => 0,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef
                                                                               }, 'Parse::RecDescent::Production' ),
                                                                        bless( {
                                                                                 'line' => 550,
                                                                                 'uncommit' => undef,
                                                                                 'number' => 3,
                                                                                 'strcount' => 0,
                                                                                 'actcount' => 1,
                                                                                 'dircount' => 0,
                                                                                 'error' => undef,
                                                                                 'patcount' => 0,
                                                                                 'items' => [
                                                                                              bless( {
                                                                                                       'line' => 550,
                                                                                                       'lookahead' => 0,
                                                                                                       'code' => '{ $arg[0]; }',
                                                                                                       'hashname' => '__ACTION1__'
                                                                                                     }, 'Parse::RecDescent::Action' )
                                                                                            ]
                                                                               }, 'Parse::RecDescent::Production' )
                                                                      ],
                                                           'name' => 'addTrigFunArgs',
                                                           'vars' => '',
                                                           'changed' => 0,
                                                           'line' => 544
                                                         }, 'Parse::RecDescent::Rule' ),
                              'addOpFunArgs' => bless( {
                                                         'opcount' => 0,
                                                         'prods' => [
                                                                      bless( {
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'line' => undef,
                                                                               'uncommit' => undef,
                                                                               'number' => 0,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'hashname' => '__PATTERN1__',
                                                                                                     'lookahead' => 0,
                                                                                                     'mod' => '',
                                                                                                     'description' => '/^\\\\Z/',
                                                                                                     'line' => 537,
                                                                                                     'pattern' => '^\\Z',
                                                                                                     'ldelim' => '/',
                                                                                                     'rdelim' => '/'
                                                                                                   }, 'Parse::RecDescent::Token' ),
                                                                                            bless( {
                                                                                                     'code' => '{ $arg[0];}',
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'line' => 537,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'patcount' => 1
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'number' => 1,
                                                                               'uncommit' => undef,
                                                                               'line' => 537,
                                                                               'actcount' => 0,
                                                                               'strcount' => 0,
                                                                               'patcount' => 0,
                                                                               'dircount' => 0,
                                                                               'error' => undef,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'line' => 538,
                                                                                                     'lookahead' => 0,
                                                                                                     'argcode' => '[$arg[0]]',
                                                                                                     'implicit' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'addEasyArgs'
                                                                                                   }, 'Parse::RecDescent::Subrule' )
                                                                                          ]
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'patcount' => 0,
                                                                               'error' => undef,
                                                                               'dircount' => 0,
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'argcode' => undef,
                                                                                                     'max' => 1,
                                                                                                     'min' => 0,
                                                                                                     'repspec' => '?',
                                                                                                     'expected' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'APPLYOP',
                                                                                                     'line' => 540,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Repetition' ),
                                                                                            bless( {
                                                                                                     'argcode' => undef,
                                                                                                     'implicit' => undef,
                                                                                                     'matchrule' => 0,
                                                                                                     'subrule' => 'barearg',
                                                                                                     'line' => 540,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Subrule' ),
                                                                                            bless( {
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'code' => '{ Apply($arg[0],$item[2]);}',
                                                                                                     'lookahead' => 0,
                                                                                                     'line' => 540
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'number' => 2,
                                                                               'line' => 539,
                                                                               'uncommit' => undef,
                                                                               'strcount' => 0,
                                                                               'actcount' => 1
                                                                             }, 'Parse::RecDescent::Production' ),
                                                                      bless( {
                                                                               'items' => [
                                                                                            bless( {
                                                                                                     'code' => '{ $arg[0]; }',
                                                                                                     'hashname' => '__ACTION1__',
                                                                                                     'line' => 541,
                                                                                                     'lookahead' => 0
                                                                                                   }, 'Parse::RecDescent::Action' )
                                                                                          ],
                                                                               'error' => undef,
                                                                               'dircount' => 0,
                                                                               'patcount' => 0,
                                                                               'strcount' => 0,
                                                                               'actcount' => 1,
                                                                               'line' => 541,
                                                                               'uncommit' => undef,
                                                                               'number' => 3
                                                                             }, 'Parse::RecDescent::Production' )
                                                                    ],
                                                         'name' => 'addOpFunArgs',
                                                         'calls' => [
                                                                      'addEasyArgs',
                                                                      'APPLYOP',
                                                                      'barearg'
                                                                    ],
                                                         'impcount' => 0,
                                                         'line' => 535,
                                                         'changed' => 0,
                                                         'vars' => ''
                                                       }, 'Parse::RecDescent::Rule' ),
                              '_alternation_1_of_production_2_of_rule_Superscript' => bless( {
                                                                                               'opcount' => 0,
                                                                                               'vars' => '',
                                                                                               'changed' => 0,
                                                                                               'line' => 791,
                                                                                               'impcount' => 0,
                                                                                               'calls' => [
                                                                                                            'PUNCT',
                                                                                                            'aSuperscript'
                                                                                                          ],
                                                                                               'name' => '_alternation_1_of_production_2_of_rule_Superscript',
                                                                                               'prods' => [
                                                                                                            bless( {
                                                                                                                     'patcount' => 0,
                                                                                                                     'dircount' => 0,
                                                                                                                     'error' => undef,
                                                                                                                     'items' => [
                                                                                                                                  bless( {
                                                                                                                                           'min' => 0,
                                                                                                                                           'max' => 1,
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'line' => 791,
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'subrule' => 'PUNCT',
                                                                                                                                           'expected' => undef,
                                                                                                                                           'repspec' => '?'
                                                                                                                                         }, 'Parse::RecDescent::Repetition' ),
                                                                                                                                  bless( {
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0,
                                                                                                                                           'implicit' => undef,
                                                                                                                                           'argcode' => undef,
                                                                                                                                           'matchrule' => 0,
                                                                                                                                           'subrule' => 'aSuperscript'
                                                                                                                                         }, 'Parse::RecDescent::Subrule' ),
                                                                                                                                  bless( {
                                                                                                                                           'code' => '{[$item[1]->[0] || InvisibleComma(),$item[2]]; }',
                                                                                                                                           'hashname' => '__ACTION1__',
                                                                                                                                           'line' => 791,
                                                                                                                                           'lookahead' => 0
                                                                                                                                         }, 'Parse::RecDescent::Action' )
                                                                                                                                ],
                                                                                                                     'number' => 0,
                                                                                                                     'uncommit' => undef,
                                                                                                                     'line' => undef,
                                                                                                                     'actcount' => 1,
                                                                                                                     'strcount' => 0
                                                                                                                   }, 'Parse::RecDescent::Production' )
                                                                                                          ]
                                                                                             }, 'Parse::RecDescent::Rule' ),
                              'relopExpr' => bless( {
                                                      'vars' => '',
                                                      'changed' => 0,
                                                      'line' => 177,
                                                      'impcount' => 0,
                                                      'calls' => [
                                                                   'relop',
                                                                   'Expression'
                                                                 ],
                                                      'name' => 'relopExpr',
                                                      'prods' => [
                                                                   bless( {
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'number' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 177,
                                                                                                  'subrule' => 'relop',
                                                                                                  'matchrule' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'subrule' => 'Expression',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => undef,
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 177
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'line' => 177,
                                                                                                  'lookahead' => 0,
                                                                                                  'code' => '{ [$item[1],$item[2]]; }',
                                                                                                  'hashname' => '__ACTION1__'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'patcount' => 1,
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 178,
                                                                                                  'subrule' => 'relop',
                                                                                                  'matchrule' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'description' => '/^\\\\Z/',
                                                                                                  'line' => 178,
                                                                                                  'mod' => '',
                                                                                                  'lookahead' => 0,
                                                                                                  'rdelim' => '/',
                                                                                                  'ldelim' => '/',
                                                                                                  'pattern' => '^\\Z',
                                                                                                  'hashname' => '__PATTERN1__'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 178,
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ [$item[1], Absent()]; }'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'number' => 1,
                                                                            'line' => 178,
                                                                            'uncommit' => undef,
                                                                            'strcount' => 0,
                                                                            'actcount' => 1
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'opcount' => 0
                                                    }, 'Parse::RecDescent::Rule' ),
                              'maybeArgs' => bless( {
                                                      'opcount' => 0,
                                                      'prods' => [
                                                                   bless( {
                                                                            'strcount' => 0,
                                                                            'actcount' => 1,
                                                                            'number' => 0,
                                                                            'line' => undef,
                                                                            'uncommit' => undef,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'hashname' => '__PATTERN1__',
                                                                                                  'lookahead' => 0,
                                                                                                  'mod' => '',
                                                                                                  'description' => '/^\\\\Z/',
                                                                                                  'line' => 490,
                                                                                                  'pattern' => '^\\Z',
                                                                                                  'ldelim' => '/',
                                                                                                  'rdelim' => '/'
                                                                                                }, 'Parse::RecDescent::Token' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 490,
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ $arg[0];}'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'patcount' => 1,
                                                                            'error' => undef,
                                                                            'dircount' => 0
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'actcount' => 0,
                                                                            'strcount' => 0,
                                                                            'uncommit' => undef,
                                                                            'line' => 490,
                                                                            'number' => 1,
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 491,
                                                                                                  'subrule' => 'APPLYOP',
                                                                                                  'matchrule' => 0,
                                                                                                  'argcode' => undef,
                                                                                                  'implicit' => undef
                                                                                                }, 'Parse::RecDescent::Subrule' ),
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 491,
                                                                                                  'subrule' => 'requireArgs',
                                                                                                  'matchrule' => 0,
                                                                                                  'implicit' => undef,
                                                                                                  'argcode' => '[$arg[0]]'
                                                                                                }, 'Parse::RecDescent::Subrule' )
                                                                                       ],
                                                                            'error' => undef,
                                                                            'dircount' => 0,
                                                                            'patcount' => 0
                                                                          }, 'Parse::RecDescent::Production' ),
                                                                   bless( {
                                                                            'items' => [
                                                                                         bless( {
                                                                                                  'lookahead' => 0,
                                                                                                  'line' => 492,
                                                                                                  'hashname' => '__ACTION1__',
                                                                                                  'code' => '{ $arg[0]; }'
                                                                                                }, 'Parse::RecDescent::Action' )
                                                                                       ],
                                                                            'dircount' => 0,
                                                                            'error' => undef,
                                                                            'patcount' => 0,
                                                                            'actcount' => 1,
                                                                            'strcount' => 0,
                                                                            'uncommit' => undef,
                                                                            'line' => 492,
                                                                            'number' => 2
                                                                          }, 'Parse::RecDescent::Production' )
                                                                 ],
                                                      'name' => 'maybeArgs',
                                                      'calls' => [
                                                                   'APPLYOP',
                                                                   'requireArgs'
                                                                 ],
                                                      'impcount' => 0,
                                                      'line' => 488,
                                                      'changed' => 0,
                                                      'vars' => ''
                                                    }, 'Parse::RecDescent::Rule' ),
                              'diffd' => bless( {
                                                  'opcount' => 0,
                                                  'calls' => [],
                                                  'prods' => [
                                                               bless( {
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'hashname' => '__PATTERN1__',
                                                                                              'description' => '/UNKNOWN:d:\\\\d+/',
                                                                                              'line' => 633,
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'ldelim' => '/',
                                                                                              'rdelim' => '/',
                                                                                              'pattern' => 'UNKNOWN:d:\\d+'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 633,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'error' => undef,
                                                                        'dircount' => 0,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'actcount' => 1,
                                                                        'strcount' => 0,
                                                                        'number' => 1,
                                                                        'uncommit' => undef,
                                                                        'line' => 634,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'mod' => '',
                                                                                              'lookahead' => 0,
                                                                                              'line' => 634,
                                                                                              'description' => '/ID:d:\\\\d+/',
                                                                                              'pattern' => 'ID:d:\\d+',
                                                                                              'ldelim' => '/',
                                                                                              'rdelim' => '/',
                                                                                              'hashname' => '__PATTERN1__'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 634,
                                                                                              'hashname' => '__ACTION1__',
                                                                                              'code' => '{ Lookup($item[1]); }'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'patcount' => 1,
                                                                        'error' => undef,
                                                                        'dircount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'diffd',
                                                  'impcount' => 0,
                                                  'line' => 632,
                                                  'vars' => '',
                                                  'changed' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'Start' => bless( {
                                                  'opcount' => 0,
                                                  'vars' => '',
                                                  'changed' => 0,
                                                  'line' => 58,
                                                  'impcount' => 0,
                                                  'calls' => [
                                                               'Anything'
                                                             ],
                                                  'prods' => [
                                                               bless( {
                                                                        'patcount' => 1,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'line' => 60,
                                                                                              'lookahead' => 0,
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'subrule' => 'Anything',
                                                                                              'matchrule' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'pattern' => '^\\Z',
                                                                                              'ldelim' => '/',
                                                                                              'rdelim' => '/',
                                                                                              'lookahead' => 0,
                                                                                              'mod' => '',
                                                                                              'line' => 60,
                                                                                              'description' => '/^\\\\Z/',
                                                                                              'hashname' => '__PATTERN1__'
                                                                                            }, 'Parse::RecDescent::Token' ),
                                                                                     bless( {
                                                                                              'line' => 60,
                                                                                              'lookahead' => 0,
                                                                                              'code' => '{ $item[1]; }',
                                                                                              'hashname' => '__ACTION1__'
                                                                                            }, 'Parse::RecDescent::Action' )
                                                                                   ],
                                                                        'number' => 0,
                                                                        'uncommit' => undef,
                                                                        'line' => undef,
                                                                        'actcount' => 1,
                                                                        'strcount' => 0
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'Start'
                                                }, 'Parse::RecDescent::Rule' ),
                              'FLOATSUPERSCRIPT' => bless( {
                                                             'opcount' => 0,
                                                             'changed' => 0,
                                                             'vars' => '',
                                                             'line' => 787,
                                                             'impcount' => 0,
                                                             'name' => 'FLOATSUPERSCRIPT',
                                                             'prods' => [
                                                                          bless( {
                                                                                   'patcount' => 1,
                                                                                   'dircount' => 0,
                                                                                   'error' => undef,
                                                                                   'items' => [
                                                                                                bless( {
                                                                                                         'hashname' => '__PATTERN1__',
                                                                                                         'pattern' => 'FLOATSUPERSCRIPT:\\S*:\\d+',
                                                                                                         'ldelim' => '/',
                                                                                                         'rdelim' => '/',
                                                                                                         'lookahead' => 0,
                                                                                                         'mod' => '',
                                                                                                         'description' => '/FLOATSUPERSCRIPT:\\\\S*:\\\\d+/',
                                                                                                         'line' => 787
                                                                                                       }, 'Parse::RecDescent::Token' ),
                                                                                                bless( {
                                                                                                         'line' => 787,
                                                                                                         'lookahead' => 0,
                                                                                                         'code' => '{ Lookup($item[1]); }',
                                                                                                         'hashname' => '__ACTION1__'
                                                                                                       }, 'Parse::RecDescent::Action' )
                                                                                              ],
                                                                                   'number' => 0,
                                                                                   'uncommit' => undef,
                                                                                   'line' => undef,
                                                                                   'actcount' => 1,
                                                                                   'strcount' => 0
                                                                                 }, 'Parse::RecDescent::Production' )
                                                                        ],
                                                             'calls' => []
                                                           }, 'Parse::RecDescent::Rule' ),
                              'preScripted' => bless( {
                                                        'opcount' => 0,
                                                        'impcount' => 0,
                                                        'calls' => [
                                                                     'FLOATSUPERSCRIPT',
                                                                     'inpreScripted',
                                                                     'FLOATSUBSCRIPT',
                                                                     'addScripts'
                                                                   ],
                                                        'name' => 'preScripted',
                                                        'prods' => [
                                                                     bless( {
                                                                              'actcount' => 1,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => undef,
                                                                              'number' => 0,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 419,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'FLOATSUPERSCRIPT',
                                                                                                    'argcode' => undef,
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 419,
                                                                                                    'matchrule' => 0,
                                                                                                    'subrule' => 'inpreScripted',
                                                                                                    'argcode' => '[$arg[0]]',
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'hashname' => '__ACTION1__',
                                                                                                    'code' => '{ NewScript($item[2],$item[1], \'pre\');}',
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 419
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ],
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'patcount' => 0
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'number' => 1,
                                                                              'line' => 420,
                                                                              'uncommit' => undef,
                                                                              'strcount' => 0,
                                                                              'actcount' => 1,
                                                                              'patcount' => 0,
                                                                              'dircount' => 0,
                                                                              'error' => undef,
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'line' => 420,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'subrule' => 'FLOATSUBSCRIPT',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'lookahead' => 0,
                                                                                                    'line' => 420,
                                                                                                    'subrule' => 'inpreScripted',
                                                                                                    'matchrule' => 0,
                                                                                                    'argcode' => '[$arg[0]]',
                                                                                                    'implicit' => undef
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 420,
                                                                                                    'lookahead' => 0,
                                                                                                    'code' => '{ NewScript($item[2],$item[1], \'pre\');}',
                                                                                                    'hashname' => '__ACTION1__'
                                                                                                  }, 'Parse::RecDescent::Action' )
                                                                                         ]
                                                                            }, 'Parse::RecDescent::Production' ),
                                                                     bless( {
                                                                              'items' => [
                                                                                           bless( {
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => undef,
                                                                                                    'matchrule' => 1,
                                                                                                    'subrule' => '$arg[0]',
                                                                                                    'line' => 421,
                                                                                                    'lookahead' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' ),
                                                                                           bless( {
                                                                                                    'line' => 421,
                                                                                                    'lookahead' => 0,
                                                                                                    'implicit' => undef,
                                                                                                    'argcode' => '[$item[1]]',
                                                                                                    'subrule' => 'addScripts',
                                                                                                    'matchrule' => 0
                                                                                                  }, 'Parse::RecDescent::Subrule' )
                                                                                         ],
                                                                              'error' => undef,
                                                                              'dircount' => 0,
                                                                              'patcount' => 0,
                                                                              'actcount' => 0,
                                                                              'strcount' => 0,
                                                                              'uncommit' => undef,
                                                                              'line' => 421,
                                                                              'number' => 2
                                                                            }, 'Parse::RecDescent::Production' )
                                                                   ],
                                                        'vars' => '',
                                                        'changed' => 0,
                                                        'line' => 417
                                                      }, 'Parse::RecDescent::Rule' ),
                              'inpreScripted' => bless( {
                                                          'impcount' => 0,
                                                          'calls' => [
                                                                       'POSTSUPERSCRIPT',
                                                                       'inpreScripted',
                                                                       'POSTSUBSCRIPT',
                                                                       'FLOATSUPERSCRIPT',
                                                                       'FLOATSUBSCRIPT',
                                                                       'addScripts'
                                                                     ],
                                                          'name' => 'inpreScripted',
                                                          'prods' => [
                                                                       bless( {
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'number' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'POSTSUPERSCRIPT',
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 424
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 424,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'inpreScripted',
                                                                                                      'argcode' => '[$arg[0]]',
                                                                                                      'implicit' => undef
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 424,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ NewScript($item[2],$item[1], \'pre\');}'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'number' => 1,
                                                                                'line' => 425,
                                                                                'uncommit' => undef,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1,
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'line' => 425,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef,
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'POSTSUBSCRIPT'
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$arg[0]]',
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'inpreScripted',
                                                                                                      'line' => 425,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 425,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ NewScript($item[2],$item[1], \'pre\');}'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ]
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 426,
                                                                                                      'subrule' => 'FLOATSUPERSCRIPT',
                                                                                                      'matchrule' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => undef
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'line' => 426,
                                                                                                      'lookahead' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$arg[0]]',
                                                                                                      'subrule' => 'inpreScripted',
                                                                                                      'matchrule' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ NewScript($item[2],$item[1], \'pre\');}',
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 426
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'actcount' => 1,
                                                                                'strcount' => 0,
                                                                                'uncommit' => undef,
                                                                                'line' => 426,
                                                                                'number' => 2
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'dircount' => 0,
                                                                                'error' => undef,
                                                                                'patcount' => 0,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'subrule' => 'FLOATSUBSCRIPT',
                                                                                                      'matchrule' => 0,
                                                                                                      'line' => 427,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 427,
                                                                                                      'subrule' => 'inpreScripted',
                                                                                                      'matchrule' => 0,
                                                                                                      'implicit' => undef,
                                                                                                      'argcode' => '[$arg[0]]'
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 427,
                                                                                                      'hashname' => '__ACTION1__',
                                                                                                      'code' => '{ NewScript($item[2],$item[1], \'pre\');}'
                                                                                                    }, 'Parse::RecDescent::Action' )
                                                                                           ],
                                                                                'line' => 427,
                                                                                'uncommit' => undef,
                                                                                'number' => 3,
                                                                                'strcount' => 0,
                                                                                'actcount' => 1
                                                                              }, 'Parse::RecDescent::Production' ),
                                                                       bless( {
                                                                                'actcount' => 0,
                                                                                'strcount' => 0,
                                                                                'number' => 4,
                                                                                'uncommit' => undef,
                                                                                'line' => 428,
                                                                                'items' => [
                                                                                             bless( {
                                                                                                      'argcode' => undef,
                                                                                                      'implicit' => undef,
                                                                                                      'matchrule' => 1,
                                                                                                      'subrule' => '$arg[0]',
                                                                                                      'line' => 428,
                                                                                                      'lookahead' => 0
                                                                                                    }, 'Parse::RecDescent::Subrule' ),
                                                                                             bless( {
                                                                                                      'matchrule' => 0,
                                                                                                      'subrule' => 'addScripts',
                                                                                                      'argcode' => '[$item[1]]',
                                                                                                      'implicit' => undef,
                                                                                                      'lookahead' => 0,
                                                                                                      'line' => 428
                                                                                                    }, 'Parse::RecDescent::Subrule' )
                                                                                           ],
                                                                                'patcount' => 0,
                                                                                'dircount' => 0,
                                                                                'error' => undef
                                                                              }, 'Parse::RecDescent::Production' )
                                                                     ],
                                                          'vars' => '',
                                                          'changed' => 0,
                                                          'line' => 422,
                                                          'opcount' => 0
                                                        }, 'Parse::RecDescent::Rule' ),
                              'DIFFOP' => bless( {
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 782,
                                                   'impcount' => 0,
                                                   'name' => 'DIFFOP',
                                                   'prods' => [
                                                                bless( {
                                                                         'number' => 0,
                                                                         'line' => undef,
                                                                         'uncommit' => undef,
                                                                         'strcount' => 0,
                                                                         'actcount' => 1,
                                                                         'patcount' => 1,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'mod' => '',
                                                                                               'line' => 782,
                                                                                               'description' => '/DIFFOP:\\\\S*:\\\\d+/',
                                                                                               'pattern' => 'DIFFOP:\\S*:\\d+',
                                                                                               'ldelim' => '/',
                                                                                               'rdelim' => '/',
                                                                                               'hashname' => '__PATTERN1__'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'line' => 782,
                                                                                               'lookahead' => 0,
                                                                                               'code' => '{ Lookup($item[1]); }',
                                                                                               'hashname' => '__ACTION1__'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ]
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'calls' => [],
                                                   'opcount' => 0
                                                 }, 'Parse::RecDescent::Rule' ),
                              'ATOM_OR_ID' => bless( {
                                                       'opcount' => 0,
                                                       'calls' => [
                                                                    'ATOM',
                                                                    'ID',
                                                                    'ARRAY'
                                                                  ],
                                                       'prods' => [
                                                                    bless( {
                                                                             'strcount' => 0,
                                                                             'actcount' => 0,
                                                                             'number' => 0,
                                                                             'line' => undef,
                                                                             'uncommit' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 306,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'ATOM',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'number' => 1,
                                                                             'uncommit' => undef,
                                                                             'line' => 306,
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 306,
                                                                                                   'lookahead' => 0,
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'ID'
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ]
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'strcount' => 0,
                                                                             'actcount' => 0,
                                                                             'number' => 2,
                                                                             'line' => 306,
                                                                             'uncommit' => undef,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'ARRAY',
                                                                                                   'line' => 306,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'ATOM_OR_ID',
                                                       'impcount' => 0,
                                                       'line' => 306,
                                                       'vars' => '',
                                                       'changed' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'ID' => bless( {
                                               'opcount' => 0,
                                               'calls' => [],
                                               'prods' => [
                                                            bless( {
                                                                     'strcount' => 0,
                                                                     'actcount' => 1,
                                                                     'line' => undef,
                                                                     'uncommit' => undef,
                                                                     'number' => 0,
                                                                     'items' => [
                                                                                  bless( {
                                                                                           'hashname' => '__PATTERN1__',
                                                                                           'line' => 743,
                                                                                           'description' => '/ID:\\\\S*:\\\\d+/',
                                                                                           'lookahead' => 0,
                                                                                           'mod' => '',
                                                                                           'ldelim' => '/',
                                                                                           'rdelim' => '/',
                                                                                           'pattern' => 'ID:\\S*:\\d+'
                                                                                         }, 'Parse::RecDescent::Token' ),
                                                                                  bless( {
                                                                                           'lookahead' => 0,
                                                                                           'line' => 743,
                                                                                           'hashname' => '__ACTION1__',
                                                                                           'code' => '{ Lookup($item[1]); }'
                                                                                         }, 'Parse::RecDescent::Action' )
                                                                                ],
                                                                     'dircount' => 0,
                                                                     'error' => undef,
                                                                     'patcount' => 1
                                                                   }, 'Parse::RecDescent::Production' )
                                                          ],
                                               'name' => 'ID',
                                               'impcount' => 0,
                                               'line' => 743,
                                               'vars' => '',
                                               'changed' => 0
                                             }, 'Parse::RecDescent::Rule' ),
                              'addOpDecoration' => bless( {
                                                            'opcount' => 0,
                                                            'calls' => [
                                                                         'POSTSUPERSCRIPT',
                                                                         'addOpDecoration',
                                                                         'POSTSUBSCRIPT'
                                                                       ],
                                                            'prods' => [
                                                                         bless( {
                                                                                  'actcount' => 1,
                                                                                  'strcount' => 0,
                                                                                  'uncommit' => undef,
                                                                                  'line' => undef,
                                                                                  'number' => 0,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'ldelim' => '/',
                                                                                                        'rdelim' => '/',
                                                                                                        'pattern' => '^\\Z',
                                                                                                        'description' => '/^\\\\Z/',
                                                                                                        'line' => 678,
                                                                                                        'lookahead' => 0,
                                                                                                        'mod' => '',
                                                                                                        'hashname' => '__PATTERN1__'
                                                                                                      }, 'Parse::RecDescent::Token' ),
                                                                                               bless( {
                                                                                                        'hashname' => '__ACTION1__',
                                                                                                        'code' => '{ $arg[0];}',
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 678
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ],
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'patcount' => 1
                                                                                }, 'Parse::RecDescent::Production' ),
                                                                         bless( {
                                                                                  'uncommit' => undef,
                                                                                  'line' => 678,
                                                                                  'number' => 1,
                                                                                  'actcount' => 0,
                                                                                  'strcount' => 0,
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'patcount' => 0,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'argcode' => undef,
                                                                                                        'implicit' => undef,
                                                                                                        'matchrule' => 0,
                                                                                                        'subrule' => 'POSTSUPERSCRIPT',
                                                                                                        'line' => 679,
                                                                                                        'lookahead' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'subrule' => 'addOpDecoration',
                                                                                                        'matchrule' => 0,
                                                                                                        'argcode' => '[DecorateOperator($arg[0],$item[1])]',
                                                                                                        'implicit' => undef,
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 679
                                                                                                      }, 'Parse::RecDescent::Subrule' )
                                                                                             ]
                                                                                }, 'Parse::RecDescent::Production' ),
                                                                         bless( {
                                                                                  'strcount' => 0,
                                                                                  'actcount' => 0,
                                                                                  'line' => 680,
                                                                                  'uncommit' => undef,
                                                                                  'number' => 2,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'subrule' => 'POSTSUBSCRIPT',
                                                                                                        'matchrule' => 0,
                                                                                                        'implicit' => undef,
                                                                                                        'argcode' => undef,
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 680
                                                                                                      }, 'Parse::RecDescent::Subrule' ),
                                                                                               bless( {
                                                                                                        'line' => 680,
                                                                                                        'lookahead' => 0,
                                                                                                        'implicit' => undef,
                                                                                                        'argcode' => '[DecorateOperator($arg[0],$item[1])]',
                                                                                                        'subrule' => 'addOpDecoration',
                                                                                                        'matchrule' => 0
                                                                                                      }, 'Parse::RecDescent::Subrule' )
                                                                                             ],
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'patcount' => 0
                                                                                }, 'Parse::RecDescent::Production' ),
                                                                         bless( {
                                                                                  'dircount' => 0,
                                                                                  'error' => undef,
                                                                                  'patcount' => 0,
                                                                                  'items' => [
                                                                                               bless( {
                                                                                                        'hashname' => '__ACTION1__',
                                                                                                        'code' => '{ $arg[0]; }',
                                                                                                        'lookahead' => 0,
                                                                                                        'line' => 681
                                                                                                      }, 'Parse::RecDescent::Action' )
                                                                                             ],
                                                                                  'uncommit' => undef,
                                                                                  'line' => 681,
                                                                                  'number' => 3,
                                                                                  'actcount' => 1,
                                                                                  'strcount' => 0
                                                                                }, 'Parse::RecDescent::Production' )
                                                                       ],
                                                            'name' => 'addOpDecoration',
                                                            'impcount' => 0,
                                                            'line' => 676,
                                                            'vars' => '',
                                                            'changed' => 0
                                                          }, 'Parse::RecDescent::Rule' ),
                              'moreRHS' => bless( {
                                                    'changed' => 0,
                                                    'vars' => '',
                                                    'line' => 152,
                                                    'impcount' => 0,
                                                    'prods' => [
                                                                 bless( {
                                                                          'strcount' => 0,
                                                                          'actcount' => 1,
                                                                          'line' => undef,
                                                                          'uncommit' => undef,
                                                                          'number' => 0,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'mod' => '',
                                                                                                'lookahead' => 0,
                                                                                                'line' => 154,
                                                                                                'description' => '/^\\\\Z/',
                                                                                                'pattern' => '^\\Z',
                                                                                                'rdelim' => '/',
                                                                                                'ldelim' => '/',
                                                                                                'hashname' => '__PATTERN1__'
                                                                                              }, 'Parse::RecDescent::Token' ),
                                                                                       bless( {
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'code' => '{ NewFormula($arg[0],$arg[1],$arg[2]); }',
                                                                                                'lookahead' => 0,
                                                                                                'line' => 154
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 1
                                                                        }, 'Parse::RecDescent::Production' ),
                                                                 bless( {
                                                                          'strcount' => 0,
                                                                          'actcount' => 0,
                                                                          'line' => 154,
                                                                          'uncommit' => undef,
                                                                          'number' => 1,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'lookahead' => 0,
                                                                                                'line' => 155,
                                                                                                'subrule' => 'PUNCT',
                                                                                                'matchrule' => 0,
                                                                                                'implicit' => undef,
                                                                                                'argcode' => undef
                                                                                              }, 'Parse::RecDescent::Subrule' ),
                                                                                       bless( {
                                                                                                'line' => 155,
                                                                                                'lookahead' => 0,
                                                                                                'argcode' => undef,
                                                                                                'implicit' => undef,
                                                                                                'matchrule' => 0,
                                                                                                'subrule' => 'Expression'
                                                                                              }, 'Parse::RecDescent::Subrule' ),
                                                                                       bless( {
                                                                                                'argcode' => '[@arg,$item[1],$item[2]]',
                                                                                                'implicit' => undef,
                                                                                                'subrule' => 'maybeColRHS',
                                                                                                'matchrule' => 0,
                                                                                                'line' => 155,
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::Subrule' )
                                                                                     ],
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'patcount' => 0
                                                                        }, 'Parse::RecDescent::Production' ),
                                                                 bless( {
                                                                          'number' => 2,
                                                                          'uncommit' => undef,
                                                                          'line' => 156,
                                                                          'actcount' => 1,
                                                                          'strcount' => 0,
                                                                          'patcount' => 0,
                                                                          'dircount' => 0,
                                                                          'error' => undef,
                                                                          'items' => [
                                                                                       bless( {
                                                                                                'argcode' => undef,
                                                                                                'max' => 100000000,
                                                                                                'min' => 0,
                                                                                                'expected' => undef,
                                                                                                'repspec' => 's?',
                                                                                                'subrule' => 'relopExpr',
                                                                                                'matchrule' => 0,
                                                                                                'line' => 156,
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::Repetition' ),
                                                                                       bless( {
                                                                                                'code' => '{ NewFormula($arg[0],$arg[1],$arg[2],
                                     map(@$_,@{$item[1]})); }',
                                                                                                'hashname' => '__ACTION1__',
                                                                                                'line' => 156,
                                                                                                'lookahead' => 0
                                                                                              }, 'Parse::RecDescent::Action' )
                                                                                     ]
                                                                        }, 'Parse::RecDescent::Production' )
                                                               ],
                                                    'name' => 'moreRHS',
                                                    'calls' => [
                                                                 'PUNCT',
                                                                 'Expression',
                                                                 'maybeColRHS',
                                                                 'relopExpr'
                                                               ],
                                                    'opcount' => 0
                                                  }, 'Parse::RecDescent::Rule' ),
                              'operator' => bless( {
                                                     'opcount' => 0,
                                                     'calls' => [
                                                                  'OPERATOR'
                                                                ],
                                                     'prods' => [
                                                                  bless( {
                                                                           'line' => undef,
                                                                           'uncommit' => undef,
                                                                           'number' => 0,
                                                                           'strcount' => 0,
                                                                           'actcount' => 0,
                                                                           'dircount' => 0,
                                                                           'error' => undef,
                                                                           'patcount' => 0,
                                                                           'items' => [
                                                                                        bless( {
                                                                                                 'implicit' => undef,
                                                                                                 'argcode' => undef,
                                                                                                 'matchrule' => 0,
                                                                                                 'subrule' => 'OPERATOR',
                                                                                                 'line' => 697,
                                                                                                 'lookahead' => 0
                                                                                               }, 'Parse::RecDescent::Subrule' )
                                                                                      ]
                                                                         }, 'Parse::RecDescent::Production' )
                                                                ],
                                                     'name' => 'operator',
                                                     'impcount' => 0,
                                                     'line' => 697,
                                                     'vars' => '',
                                                     'changed' => 0
                                                   }, 'Parse::RecDescent::Rule' ),
                              'aSubscript' => bless( {
                                                       'opcount' => 0,
                                                       'line' => 94,
                                                       'vars' => '',
                                                       'changed' => 0,
                                                       'calls' => [
                                                                    'Formulae',
                                                                    'AnyOp',
                                                                    'Expression'
                                                                  ],
                                                       'name' => 'aSubscript',
                                                       'prods' => [
                                                                    bless( {
                                                                             'strcount' => 0,
                                                                             'actcount' => 0,
                                                                             'line' => undef,
                                                                             'uncommit' => undef,
                                                                             'number' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'lookahead' => 0,
                                                                                                   'line' => 95,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'Formulae',
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'AnyOp',
                                                                                                   'line' => 96,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'line' => 96,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'subrule' => 'Expression',
                                                                                                   'matchrule' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'code' => '{ Apply($item[1],Absent(),$item[2]);}',
                                                                                                   'hashname' => '__ACTION1__',
                                                                                                   'line' => 96,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'line' => 96,
                                                                             'uncommit' => undef,
                                                                             'number' => 1,
                                                                             'strcount' => 0,
                                                                             'actcount' => 1
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'number' => 2,
                                                                             'uncommit' => undef,
                                                                             'line' => 97,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 97,
                                                                                                   'lookahead' => 0,
                                                                                                   'argcode' => undef,
                                                                                                   'implicit' => undef,
                                                                                                   'subrule' => 'AnyOp',
                                                                                                   'matchrule' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'patcount' => 0,
                                                                             'dircount' => 0,
                                                                             'error' => undef
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'impcount' => 0
                                                     }, 'Parse::RecDescent::Rule' ),
                              'AddOp' => bless( {
                                                  'prods' => [
                                                               bless( {
                                                                        'strcount' => 0,
                                                                        'actcount' => 0,
                                                                        'number' => 0,
                                                                        'line' => undef,
                                                                        'uncommit' => undef,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'BINOP',
                                                                                              'line' => 667,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 667,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'addOpDecoration',
                                                                                              'argcode' => '[$item[1]]',
                                                                                              'implicit' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ],
                                                                        'patcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef
                                                                      }, 'Parse::RecDescent::Production' ),
                                                               bless( {
                                                                        'uncommit' => undef,
                                                                        'line' => 668,
                                                                        'number' => 1,
                                                                        'actcount' => 0,
                                                                        'strcount' => 0,
                                                                        'dircount' => 0,
                                                                        'error' => undef,
                                                                        'patcount' => 0,
                                                                        'items' => [
                                                                                     bless( {
                                                                                              'lookahead' => 0,
                                                                                              'line' => 668,
                                                                                              'matchrule' => 0,
                                                                                              'subrule' => 'ADDOP',
                                                                                              'implicit' => undef,
                                                                                              'argcode' => undef
                                                                                            }, 'Parse::RecDescent::Subrule' ),
                                                                                     bless( {
                                                                                              'argcode' => '[$item[1]]',
                                                                                              'implicit' => undef,
                                                                                              'subrule' => 'addOpDecoration',
                                                                                              'matchrule' => 0,
                                                                                              'line' => 668,
                                                                                              'lookahead' => 0
                                                                                            }, 'Parse::RecDescent::Subrule' )
                                                                                   ]
                                                                      }, 'Parse::RecDescent::Production' )
                                                             ],
                                                  'name' => 'AddOp',
                                                  'calls' => [
                                                               'BINOP',
                                                               'addOpDecoration',
                                                               'ADDOP'
                                                             ],
                                                  'impcount' => 0,
                                                  'line' => 666,
                                                  'changed' => 0,
                                                  'vars' => '',
                                                  'opcount' => 0
                                                }, 'Parse::RecDescent::Rule' ),
                              'PERIOD' => bless( {
                                                   'impcount' => 0,
                                                   'prods' => [
                                                                bless( {
                                                                         'patcount' => 1,
                                                                         'dircount' => 0,
                                                                         'error' => undef,
                                                                         'items' => [
                                                                                      bless( {
                                                                                               'mod' => '',
                                                                                               'lookahead' => 0,
                                                                                               'description' => '/PERIOD:\\\\S*:\\\\d+/',
                                                                                               'line' => 747,
                                                                                               'pattern' => 'PERIOD:\\S*:\\d+',
                                                                                               'rdelim' => '/',
                                                                                               'ldelim' => '/',
                                                                                               'hashname' => '__PATTERN1__'
                                                                                             }, 'Parse::RecDescent::Token' ),
                                                                                      bless( {
                                                                                               'lookahead' => 0,
                                                                                               'line' => 747,
                                                                                               'hashname' => '__ACTION1__',
                                                                                               'code' => '{ Lookup($item[1]); }'
                                                                                             }, 'Parse::RecDescent::Action' )
                                                                                    ],
                                                                         'number' => 0,
                                                                         'uncommit' => undef,
                                                                         'line' => undef,
                                                                         'actcount' => 1,
                                                                         'strcount' => 0
                                                                       }, 'Parse::RecDescent::Production' )
                                                              ],
                                                   'name' => 'PERIOD',
                                                   'calls' => [],
                                                   'changed' => 0,
                                                   'vars' => '',
                                                   'line' => 747,
                                                   'opcount' => 0
                                                 }, 'Parse::RecDescent::Rule' ),
                              'moreTerms2' => bless( {
                                                       'opcount' => 0,
                                                       'calls' => [
                                                                    'Term',
                                                                    'moreTerms'
                                                                  ],
                                                       'prods' => [
                                                                    bless( {
                                                                             'actcount' => 0,
                                                                             'strcount' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => undef,
                                                                             'number' => 0,
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'implicit' => undef,
                                                                                                   'argcode' => undef,
                                                                                                   'subrule' => 'Term',
                                                                                                   'matchrule' => 0,
                                                                                                   'line' => 215,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' ),
                                                                                          bless( {
                                                                                                   'argcode' => '[ [@{$arg[0]},$arg[1],$arg[2]],$item[1] ]',
                                                                                                   'implicit' => undef,
                                                                                                   'matchrule' => 0,
                                                                                                   'subrule' => 'moreTerms',
                                                                                                   'line' => 215,
                                                                                                   'lookahead' => 0
                                                                                                 }, 'Parse::RecDescent::Subrule' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0
                                                                           }, 'Parse::RecDescent::Production' ),
                                                                    bless( {
                                                                             'items' => [
                                                                                          bless( {
                                                                                                   'line' => 216,
                                                                                                   'lookahead' => 0,
                                                                                                   'code' => '{ LeftRec(@{$arg[0]},Apply(New(\'limit-from\'),$arg[1],$arg[2])); }',
                                                                                                   'hashname' => '__ACTION1__'
                                                                                                 }, 'Parse::RecDescent::Action' )
                                                                                        ],
                                                                             'dircount' => 0,
                                                                             'error' => undef,
                                                                             'patcount' => 0,
                                                                             'actcount' => 1,
                                                                             'strcount' => 0,
                                                                             'uncommit' => undef,
                                                                             'line' => 216,
                                                                             'number' => 1
                                                                           }, 'Parse::RecDescent::Production' )
                                                                  ],
                                                       'name' => 'moreTerms2',
                                                       'impcount' => 0,
                                                       'line' => 214,
                                                       'vars' => '',
                                                       'changed' => 0
                                                     }, 'Parse::RecDescent::Rule' )
                            },
                 '_check' => {
                               'itempos' => '',
                               'prevcolumn' => '',
                               'thiscolumn' => '',
                               'prevoffset' => '',
                               'thisoffset' => '',
                               'prevline' => ''
                             },
                 'localvars' => ' $MaxAbsDepth $MaxAbsDepth $MaxAbsDepth $forbidVertBar $forbidLRAngle $forbidEvalAt $MaxAbsDepth',
                 '_AUTOACTION' => undef,
                 '_AUTOTREE' => undef
               }, 'Parse::RecDescent' );
}