File Coverage

blib/lib/Math/Symbolic/Parser/Precompiled.pm

Criterion	Covered	Total	%
statement	1987	2271	87.4
branch	629	1338	47.0
condition	191	370	51.6
subroutine	72	73	98.6
pod	0	1	0.0
total	2879	4053	71.0

line	stmt	bran	cond	sub	pod	time	code
1							package Math::Symbolic::Parser::Precompiled;
2							our $VERSION = '0.612';
3
4	23			23		162	use strict;
	23					59
	23					2254
5
6							=head1 NAME
7
8							Math::Symbolic::Parser::Precompiled - Precompiled Math::Symbolic Parser
9
10							=head1 DESCRIPTION
11
12							This module is a precompiled version of the Parse::RecDescent grammar
13							that can be found in $Math::Symbolic::Parser::Grammar. It is used internally
14							to improve startup performance. Please use the new() method in the
15							Math::Symbolic::Parser namespace to generate new parsers.
16
17							Also note that some modules on CPAN (like Math::SymbolicX::Complex, etc.) modify
18							the parser which is stored in $Math::Symbolic::Parser at the time of loading
19							the module.
20
21							=head1 AUTHOR
22
23							Please send feedback, bug reports, and support requests to the Math::Symbolic
24							support mailing list:
25							math-symbolic-support at lists dot sourceforge dot net. Please
26							consider letting us know how you use Math::Symbolic. Thank you.
27
28							If you're interested in helping with the development or extending the
29							module's functionality, please contact the developers' mailing list:
30							math-symbolic-develop at lists dot sourceforge dot net.
31
32							List of contributors:
33
34							Steffen M�ller, symbolic-module at steffen-mueller dot net
35							Stray Toaster, mwk at users dot sourceforge dot net
36							Oliver Ebenh�h
37
38							=head1 SEE ALSO
39
40							New versions of this module can be found on
41							http://steffen-mueller.net or CPAN. The module development takes place on
42							Sourceforge at http://sourceforge.net/projects/math-symbolic/
43
44							L
45
46							L
47
48							=cut
49
50							package Math::Symbolic::Parser::Precompiled;
51	23			23		144	use Parse::RecDescent;
	23					80
	23					225
52							{ my $ERRORS;
53
54
55							package Parse::RecDescent::Math::Symbolic::Parser::Precompiled;
56	23			23		1591	use strict;
	23					54
	23					803
57	23			23		127	use vars qw($skip $AUTOLOAD );
	23					53
	23					3259
58							@Parse::RecDescent::Math::Symbolic::Parser::Precompiled::ISA = ();
59							$skip = '\s*';
60
61
62							{
63							local $SIG{__WARN__} = sub {0};
64							# PRETEND TO BE IN Parse::RecDescent NAMESPACE
65							*Parse::RecDescent::Math::Symbolic::Parser::Precompiled::AUTOLOAD = sub
66							{
67	23			23		137	no strict 'refs';
	23					51
	23					3263
68
69	0			0		0	${"AUTOLOAD"} =~ s/^Parse::RecDescent::Math::Symbolic::Parser::Precompiled/Parse::RecDescent/;
	0					0
70	0					0	goto &{${"AUTOLOAD"}};
	0					0
	0					0
71							}
72							}
73
74							push @Parse::RecDescent::Math::Symbolic::Parser::Precompiled::ISA, 'Parse::RecDescent';
75							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
76							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::exp
77							{
78	2907			2907		4656	my $thisparser = $_[0];
79	23			23		129	use vars q{$tracelevel};
	23					66
	23					12651
80	2907		50			13712	local $tracelevel = ($tracelevel\|\|0)+1;
81	2907					3597	$ERRORS = 0;
82	2907					6904	my $thisrule = $thisparser->{"rules"}{"exp"};
83
84	2907	50				5758	Parse::RecDescent::_trace(q{Trying rule: [exp]},
85							Parse::RecDescent::_tracefirst($_[1]),
86							q{exp},
87							$tracelevel)
88							if defined $::RD_TRACE;
89
90
91	2907					3893	my $err_at = @{$thisparser->{errors}};
	2907					5854
92
93	2907					4222	my $score;
94							my $score_return;
95	0					0	my $_tok;
96	2907					3671	my $return = undef;
97	2907					5228	my $_matched=0;
98	2907					3614	my $commit=0;
99	2907					4482	my @item = ();
100	2907					4626	my %item = ();
101	2907					4109	my $repeating = $_[2];
102	2907					3470	my $_noactions = $_[3];
103	2907	50				6199	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2907					3641
	2907					6198
104	2907					4233	my $_itempos = $_[5];
105	2907	50				7694	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
106	2907					4494	my $text;
107							my $lastsep;
108	0					0	my $current_match;
109	2907					10410	my $expectation = new Parse::RecDescent::Expectation(q{});
110	2907					24705	$expectation->at($_[1]);
111
112	2907					11908	my $thisline;
113	2907					12424	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
114
115
116
117	2907		33			28332	while (!$_matched && !$commit)
118							{
119
120	2907	50				6344	Parse::RecDescent::_trace(q{Trying production: []},
121							Parse::RecDescent::_tracefirst($_[1]),
122							q{exp},
123							$tracelevel)
124							if defined $::RD_TRACE;
125	2907					7953	my $thisprod = $thisrule->{"prods"}[0];
126	2907					4675	$text = $_[1];
127	2907					3439	my $_savetext;
128	2907					5378	@item = (q{exp});
129	2907					8972	%item = (__RULE__ => q{exp});
130	2907					3857	my $repcount = 0;
131
132
133	2907	50				6144	Parse::RecDescent::_trace(q{Trying operator: []},
134							Parse::RecDescent::_tracefirst($text),
135							q{exp},
136							$tracelevel)
137							if defined $::RD_TRACE;
138	2907					8322	$expectation->is(q{})->at($text);
139
140	2907					19263	$_tok = undef;
141	2907					3441	OPLOOP: while (1)
142							{
143	2907					3658	$repcount = 0;
144	2907					4653	my @item;
145							my %item;
146
147	2907					4337	my $savetext = $text;
148	2907					3276	my $backtrack;
149							# MATCH (LEFTARG OP)(s)
150	2907					6779	while ($repcount < 100000000)
151							{
152	3186					4091	$backtrack = 0;
153
154	3186	50				6040	Parse::RecDescent::_trace(q{Trying subrule: [factor]},
155							Parse::RecDescent::_tracefirst($text),
156							q{exp},
157							$tracelevel)
158							if defined $::RD_TRACE;
159	23			23		195	if (1) { no strict qw{refs};
	23					63
	23					12575
	3186					3729
160	3186					9081	$expectation->is(q{factor})->at($text);
161	3186	50		3186		40305	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	3186					6655
162							{
163
164	0	0				0	Parse::RecDescent::_trace(q{<>},
165							Parse::RecDescent::_tracefirst($text),
166							q{exp},
167							$tracelevel)
168							if defined $::RD_TRACE;
169	0					0	$expectation->failed();
170	0					0	last;
171							}
172	3186	50				13513	Parse::RecDescent::_trace(q{>>Matched subrule: [factor]<< (return value: [}
173							. $_tok . q{]},
174
175							Parse::RecDescent::_tracefirst($text),
176							q{exp},
177							$tracelevel)
178							if defined $::RD_TRACE;
179	3186					6872	$item{q{factor}} = $_tok;
180	3186					5238	push @item, $_tok;
181
182							}
183
184
185	3186					4454	$repcount++;
186	3186					4669	$backtrack = 1;
187
188	3186	50				6335	Parse::RecDescent::_trace(q{Trying terminal: ['^']},
189							Parse::RecDescent::_tracefirst($text),
190							q{exp},
191							$tracelevel)
192							if defined $::RD_TRACE;
193	3186					4144	undef $lastsep;
194	3186					10781	$expectation->is(q{'^'})->at($text);
195
196
197	3186	50	66			37759	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\^/)
	3186	100				28567
198							{
199	2907	50				9490	$text = $lastsep . $text if defined $lastsep;
200
201	2907					11461	$expectation->failed();
202	2907	50				43628	Parse::RecDescent::_trace(qq{<>},
203							Parse::RecDescent::_tracefirst($text))
204							if defined $::RD_TRACE;
205	2907					4924	last;
206							}
207	279					1522	$current_match = substr($text, $-[0], $+[0] - $-[0]);
208	279					974	substr($text,0,length($current_match),q{});
209	279	50				997	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
210							. $current_match . q{])},
211							Parse::RecDescent::_tracefirst($text))
212							if defined $::RD_TRACE;
213	279					933	push @item, $item{__STRING1__}=$current_match;
214
215
216	279					558	$savetext = $text;
217	279					990	pop @item;
218
219							}
220	2907					5868	$text = $savetext;
221	2907	50				6934	pop @item if $backtrack;
222
223							# MATCH RIGHTARG
224
225	2907	50				7301	Parse::RecDescent::_trace(q{Trying subrule: [factor]},
226							Parse::RecDescent::_tracefirst($text),
227							q{exp},
228							$tracelevel)
229							if defined $::RD_TRACE;
230	23			23		157	if (1) { no strict qw{refs};
	23					62
	23					26800
	2907					4510
231	2907					9990	$expectation->is(q{factor})->at($text);
232	2907	50		2907		30110	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2907					7899
233							{
234
235	0	0				0	Parse::RecDescent::_trace(q{<>},
236							Parse::RecDescent::_tracefirst($text),
237							q{exp},
238							$tracelevel)
239							if defined $::RD_TRACE;
240	0					0	$expectation->failed();
241	0					0	last;
242							}
243	2907	50				12003	Parse::RecDescent::_trace(q{>>Matched subrule: [factor]<< (return value: [}
244							. $_tok . q{]},
245
246							Parse::RecDescent::_tracefirst($text),
247							q{exp},
248							$tracelevel)
249							if defined $::RD_TRACE;
250	2907					5619	$item{q{factor}} = $_tok;
251	2907					12341	push @item, $_tok;
252
253							}
254
255	2907					4205	$repcount++;
256	2907	50				6735	unless (@item) { undef $_tok; last }
	0					0
	0					0
257	2907					6268	$_tok = [ @item ];
258
259	2907					12423	last;
260							} # end of OPLOOP
261
262	2907	50				7944	unless ($repcount>=1)
263							{
264	0	0				0	Parse::RecDescent::_trace(q{<]>>},
265							Parse::RecDescent::_tracefirst($text),
266							q{exp},
267							$tracelevel)
268							if defined $::RD_TRACE;
269	0					0	$expectation->failed();
270	0					0	last;
271							}
272	2907	50				5815	Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [}
273	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
274							Parse::RecDescent::_tracefirst($text),
275							q{exp},
276							$tracelevel)
277							if defined $::RD_TRACE;
278
279	2907		50			10041	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
280
281	2907	50				5923	Parse::RecDescent::_trace(q{Trying action},
282							Parse::RecDescent::_tracefirst($text),
283							q{exp},
284							$tracelevel)
285							if defined $::RD_TRACE;
286
287
288	2907	50				5425	$_tok = ($_noactions) ? 0 : do {
289							#warn 'exp ' if $Math::Symbolic::Parser::DEBUG;
290	2907	100				3566	if (@{$item[1]} == 1) {
	2907					7259
291	2631					5330	$item[1][0]
292							}
293							else {
294	276					496	my @it = reverse @{$item[1]};
	276					880
295	276					521	my $tree = shift @it;
296	276					737	while (@it) {
297	279					1960	$tree = Math::Symbolic::Operator->new(
298							'^', shift(@it), $tree
299							);
300							}
301	276					631	$tree;
302							}
303							};
304	2907	50				6822	unless (defined $_tok)
305							{
306	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
307							if defined $::RD_TRACE;
308	0					0	last;
309							}
310	2907	50				6273	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
311							. $_tok . q{])},
312							Parse::RecDescent::_tracefirst($text))
313							if defined $::RD_TRACE;
314	2907					4249	push @item, $_tok;
315	2907					4597	$item{__ACTION1__}=$_tok;
316
317
318	2907	50				5760	Parse::RecDescent::_trace(q{>>Matched production: []<<},
319							Parse::RecDescent::_tracefirst($text),
320							q{exp},
321							$tracelevel)
322							if defined $::RD_TRACE;
323
324
325
326	2907					3960	$_matched = 1;
327	2907					5215	last;
328							}
329
330
331	2907	50	33			16277	unless ( $_matched \|\| defined($score) )
332							{
333
334
335	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
336	0	0				0	Parse::RecDescent::_trace(q{<>},
337							Parse::RecDescent::_tracefirst($_[1]),
338							q{exp},
339							$tracelevel)
340							if defined $::RD_TRACE;
341	0					0	return undef;
342							}
343	2907	50	33			13619	if (!defined($return) && defined($score))
344							{
345	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
346							q{exp},
347							$tracelevel)
348							if defined $::RD_TRACE;
349	0					0	$return = $score_return;
350							}
351	2907					3906	splice @{$thisparser->{errors}}, $err_at;
	2907					6698
352	2907	50				7733	$return = $item[$#item] unless defined $return;
353	2907	50				6189	if (defined $::RD_TRACE)
354							{
355	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
356							$return . q{])}, "",
357							q{exp},
358							$tracelevel);
359	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
360							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
361							Parse::RecDescent::_tracefirst($text),
362							, q{exp},
363							$tracelevel)
364							}
365	2907					5576	$_[1] = $text;
366	2907					27565	return $return;
367							}
368
369							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
370							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::variable
371							{
372	3817			3817		5817	my $thisparser = $_[0];
373	23			23		179	use vars q{$tracelevel};
	23					56
	23					27351
374	3817		50			11086	local $tracelevel = ($tracelevel\|\|0)+1;
375	3817					5665	$ERRORS = 0;
376	3817					8364	my $thisrule = $thisparser->{"rules"}{"variable"};
377
378	3817	50				7710	Parse::RecDescent::_trace(q{Trying rule: [variable]},
379							Parse::RecDescent::_tracefirst($_[1]),
380							q{variable},
381							$tracelevel)
382							if defined $::RD_TRACE;
383
384
385	3817					17287	my $err_at = @{$thisparser->{errors}};
	3817					8114
386
387	3817					4958	my $score;
388							my $score_return;
389	0					0	my $_tok;
390	3817					4392	my $return = undef;
391	3817					4817	my $_matched=0;
392	3817					4446	my $commit=0;
393	3817					5475	my @item = ();
394	3817					6129	my %item = ();
395	3817					4324	my $repeating = $_[2];
396	3817					4063	my $_noactions = $_[3];
397	3817	50				7569	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	3817					3993
	3817					11488
398	3817					6327	my $_itempos = $_[5];
399	3817	50				17502	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
400	3817					4966	my $text;
401							my $lastsep;
402	0					0	my $current_match;
403	3817					12738	my $expectation = new Parse::RecDescent::Expectation(q{/[a-zA-Z][a-zA-Z0-9_]*/});
404	3817					31749	$expectation->at($_[1]);
405
406	3817					16317	my $thisline;
407	3817					20768	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
408
409
410
411	3817		33			39607	while (!$_matched && !$commit)
412							{
413
414	3817	50				9268	Parse::RecDescent::_trace(q{Trying production: [/[a-zA-Z][a-zA-Z0-9_]/ /\\'/ '(' identifier_list ')']},
415							Parse::RecDescent::_tracefirst($_[1]),
416							q{variable},
417							$tracelevel)
418							if defined $::RD_TRACE;
419	3817					9915	my $thisprod = $thisrule->{"prods"}[0];
420	3817					5739	$text = $_[1];
421	3817					4211	my $_savetext;
422	3817					7285	@item = (q{variable});
423	3817					7847	%item = (__RULE__ => q{variable});
424	3817					5299	my $repcount = 0;
425
426
427	3817	50				7795	Parse::RecDescent::_trace(q{Trying terminal: [/[a-zA-Z][a-zA-Z0-9_]*/]}, Parse::RecDescent::_tracefirst($text),
428							q{variable},
429							$tracelevel)
430							if defined $::RD_TRACE;
431	3817					4894	undef $lastsep;
432	3817					11422	$expectation->is(q{})->at($text);
433
434
435	3817	50	66			39040	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	3817	100				34480
436							{
437	625	50				2263	$text = $lastsep . $text if defined $lastsep;
438	625					2018	$expectation->failed();
439	625	50				3026	Parse::RecDescent::_trace(q{<>},
440							Parse::RecDescent::_tracefirst($text))
441							if defined $::RD_TRACE;
442
443	625					1518	last;
444							}
445	3192					15067	$current_match = substr($text, $-[0], $+[0] - $-[0]);
446	3192					9248	substr($text,0,length($current_match),q{});
447	3192	50				20915	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
448							. $current_match . q{])},
449							Parse::RecDescent::_tracefirst($text))
450							if defined $::RD_TRACE;
451	3192					11406	push @item, $item{__PATTERN1__}=$current_match;
452
453
454	3192	50				6235	Parse::RecDescent::_trace(q{Trying terminal: [/\\'*/]}, Parse::RecDescent::_tracefirst($text),
455							q{variable},
456							$tracelevel)
457							if defined $::RD_TRACE;
458	3192					4206	undef $lastsep;
459	3192					9105	$expectation->is(q{/\\'*/})->at($text);
460
461
462	3192	50	33			33166	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\'*)/)
	3192	50				28704
463							{
464	0	0				0	$text = $lastsep . $text if defined $lastsep;
465	0					0	$expectation->failed();
466	0	0				0	Parse::RecDescent::_trace(q{<>},
467							Parse::RecDescent::_tracefirst($text))
468							if defined $::RD_TRACE;
469
470	0					0	last;
471							}
472	3192					13861	$current_match = substr($text, $-[0], $+[0] - $-[0]);
473	3192					8262	substr($text,0,length($current_match),q{});
474	3192	50				7186	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
475							. $current_match . q{])},
476							Parse::RecDescent::_tracefirst($text))
477							if defined $::RD_TRACE;
478	3192					8243	push @item, $item{__PATTERN2__}=$current_match;
479
480
481	3192	50				6343	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
482							Parse::RecDescent::_tracefirst($text),
483							q{variable},
484							$tracelevel)
485							if defined $::RD_TRACE;
486	3192					6322	undef $lastsep;
487	3192					9038	$expectation->is(q{'('})->at($text);
488
489
490	3192	50	66			32020	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	3192	100				25189
491							{
492	3033	50				8625	$text = $lastsep . $text if defined $lastsep;
493
494	3033					9676	$expectation->failed();
495	3033	50				29631	Parse::RecDescent::_trace(qq{<>},
496							Parse::RecDescent::_tracefirst($text))
497							if defined $::RD_TRACE;
498	3033					6961	last;
499							}
500	159					737	$current_match = substr($text, $-[0], $+[0] - $-[0]);
501	159					409	substr($text,0,length($current_match),q{});
502	159	50				430	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
503							. $current_match . q{])},
504							Parse::RecDescent::_tracefirst($text))
505							if defined $::RD_TRACE;
506	159					380	push @item, $item{__STRING1__}=$current_match;
507
508
509	159	50				358	Parse::RecDescent::_trace(q{Trying subrule: [identifier_list]},
510							Parse::RecDescent::_tracefirst($text),
511							q{variable},
512							$tracelevel)
513							if defined $::RD_TRACE;
514	23			23		164	if (1) { no strict qw{refs};
	23					49
	23					51348
	159					238
515	159					449	$expectation->is(q{identifier_list})->at($text);
516	159	50		159		1749	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::identifier_list($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	159					3203
517							{
518
519	0	0				0	Parse::RecDescent::_trace(q{<>},
520							Parse::RecDescent::_tracefirst($text),
521							q{variable},
522							$tracelevel)
523							if defined $::RD_TRACE;
524	0					0	$expectation->failed();
525	0					0	last;
526							}
527	159	50				623	Parse::RecDescent::_trace(q{>>Matched subrule: [identifier_list]<< (return value: [}
528							. $_tok . q{]},
529
530							Parse::RecDescent::_tracefirst($text),
531							q{variable},
532							$tracelevel)
533							if defined $::RD_TRACE;
534	159					302	$item{q{identifier_list}} = $_tok;
535	159					237	push @item, $_tok;
536
537							}
538
539	159	50				330	Parse::RecDescent::_trace(q{Trying terminal: [')']},
540							Parse::RecDescent::_tracefirst($text),
541							q{variable},
542							$tracelevel)
543							if defined $::RD_TRACE;
544	159					405	undef $lastsep;
545	159					483	$expectation->is(q{')'})->at($text);
546
547
548	159	50	33			1654	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	159	50				1552
549							{
550	0	0				0	$text = $lastsep . $text if defined $lastsep;
551
552	0					0	$expectation->failed();
553	0	0				0	Parse::RecDescent::_trace(qq{<>},
554							Parse::RecDescent::_tracefirst($text))
555							if defined $::RD_TRACE;
556	0					0	last;
557							}
558	159					846	$current_match = substr($text, $-[0], $+[0] - $-[0]);
559	159					483	substr($text,0,length($current_match),q{});
560	159	50				361	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
561							. $current_match . q{])},
562							Parse::RecDescent::_tracefirst($text))
563							if defined $::RD_TRACE;
564	159					430	push @item, $item{__STRING2__}=$current_match;
565
566
567	159	50				366	Parse::RecDescent::_trace(q{Trying action},
568							Parse::RecDescent::_tracefirst($text),
569							q{variable},
570							$tracelevel)
571							if defined $::RD_TRACE;
572
573
574	159	50				274	$_tok = ($_noactions) ? 0 : do {
575							#warn 'variable '
576							# if $Math::Symbolic::Parser::DEBUG;
577	159					342	my $varname = $item[1];
578	159					237	my $ticks = $item[2];
579	159	100				295	if ($ticks) {
580	12					17	my $n = length($ticks);
581	12		50			28	my $sig = $item[4] \|\| ['x'];
582	12					16	my $dep_var = $sig->[0];
583	12					137	my $return = Math::Symbolic::Variable->new(
584							{ name => $varname, signature => $sig }
585							);
586	12					54	foreach (1..$n) {
587	18					95	$return = Math::Symbolic::Operator->new(
588							'partial_derivative',
589							$return, $dep_var,
590							);
591							}
592	12					44	$return;
593							}
594							else {
595	147					1239	Math::Symbolic::Variable->new(
596							{ name => $varname, signature => $item[4] }
597							);
598							}
599							};
600	159	50				603	unless (defined $_tok)
601							{
602	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
603							if defined $::RD_TRACE;
604	0					0	last;
605							}
606	159	50				335	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
607							. $_tok . q{])},
608							Parse::RecDescent::_tracefirst($text))
609							if defined $::RD_TRACE;
610	159					206	push @item, $_tok;
611	159					277	$item{__ACTION1__}=$_tok;
612
613
614	159	50				333	Parse::RecDescent::_trace(q{>>Matched production: [/[a-zA-Z][a-zA-Z0-9_]/ /\\'/ '(' identifier_list ')']<<},
615							Parse::RecDescent::_tracefirst($text),
616							q{variable},
617							$tracelevel)
618							if defined $::RD_TRACE;
619
620
621
622	159					195	$_matched = 1;
623	159					414	last;
624							}
625
626
627	3817		66			14279	while (!$_matched && !$commit)
628							{
629
630	3658	50				7765	Parse::RecDescent::_trace(q{Trying production: [/[a-zA-Z][a-zA-Z0-9_]/ /\\'/]},
631							Parse::RecDescent::_tracefirst($_[1]),
632							q{variable},
633							$tracelevel)
634							if defined $::RD_TRACE;
635	3658					7789	my $thisprod = $thisrule->{"prods"}[1];
636	3658					6847	$text = $_[1];
637	3658					4608	my $_savetext;
638	3658					9372	@item = (q{variable});
639	3658					9532	%item = (__RULE__ => q{variable});
640	3658					5396	my $repcount = 0;
641
642
643	3658	50				7329	Parse::RecDescent::_trace(q{Trying terminal: [/[a-zA-Z][a-zA-Z0-9_]*/]}, Parse::RecDescent::_tracefirst($text),
644							q{variable},
645							$tracelevel)
646							if defined $::RD_TRACE;
647	3658					4590	undef $lastsep;
648	3658					10108	$expectation->is(q{})->at($text);
649
650
651	3658	50	66			35527	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	3658	100				31372
652							{
653	625	50				1948	$text = $lastsep . $text if defined $lastsep;
654	625					1841	$expectation->failed();
655	625	50				2818	Parse::RecDescent::_trace(q{<>},
656							Parse::RecDescent::_tracefirst($text))
657							if defined $::RD_TRACE;
658
659	625					1192	last;
660							}
661	3033					14077	$current_match = substr($text, $-[0], $+[0] - $-[0]);
662	3033					8196	substr($text,0,length($current_match),q{});
663	3033	50				6751	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
664							. $current_match . q{])},
665							Parse::RecDescent::_tracefirst($text))
666							if defined $::RD_TRACE;
667	3033					7294	push @item, $item{__PATTERN1__}=$current_match;
668
669
670	3033	50				7117	Parse::RecDescent::_trace(q{Trying terminal: [/\\'*/]}, Parse::RecDescent::_tracefirst($text),
671							q{variable},
672							$tracelevel)
673							if defined $::RD_TRACE;
674	3033					3956	undef $lastsep;
675	3033					9182	$expectation->is(q{/\\'*/})->at($text);
676
677
678	3033	50	33			29532	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\'*)/)
	3033	50				26607
679							{
680	0	0				0	$text = $lastsep . $text if defined $lastsep;
681	0					0	$expectation->failed();
682	0	0				0	Parse::RecDescent::_trace(q{<>},
683							Parse::RecDescent::_tracefirst($text))
684							if defined $::RD_TRACE;
685
686	0					0	last;
687							}
688	3033					13405	$current_match = substr($text, $-[0], $+[0] - $-[0]);
689	3033					8166	substr($text,0,length($current_match),q{});
690	3033	50				6208	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
691							. $current_match . q{])},
692							Parse::RecDescent::_tracefirst($text))
693							if defined $::RD_TRACE;
694	3033					8889	push @item, $item{__PATTERN2__}=$current_match;
695
696
697	3033	50				6397	Parse::RecDescent::_trace(q{Trying action},
698							Parse::RecDescent::_tracefirst($text),
699							q{variable},
700							$tracelevel)
701							if defined $::RD_TRACE;
702
703
704	3033	50				5357	$_tok = ($_noactions) ? 0 : do {
705							#warn 'variable '
706							# if $Math::Symbolic::Parser::DEBUG;
707	3033					4558	my $varname = $item[1];
708	3033					3546	my $ticks = $item[2];
709	3033	100				10936	if ($ticks) {
710	4					7	my $n = length($ticks);
711	4					38	my $return = Math::Symbolic::Variable->new(
712							{ name => $varname, signature => ['x'] }
713							);
714	4					17	foreach (1..$n) {
715	6					29	$return = Math::Symbolic::Operator->new(
716							'partial_derivative',
717							$return, 'x',
718							);
719							}
720	4					12	$return;
721							}
722							else {
723	3029					15305	Math::Symbolic::Variable->new( $varname );
724							}
725							};
726	3033	50				8482	unless (defined $_tok)
727							{
728	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
729							if defined $::RD_TRACE;
730	0					0	last;
731							}
732	3033	50				6112	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
733							. $_tok . q{])},
734							Parse::RecDescent::_tracefirst($text))
735							if defined $::RD_TRACE;
736	3033					4927	push @item, $_tok;
737	3033					5311	$item{__ACTION1__}=$_tok;
738
739
740	3033	50				6251	Parse::RecDescent::_trace(q{>>Matched production: [/[a-zA-Z][a-zA-Z0-9_]/ /\\'/]<<},
741							Parse::RecDescent::_tracefirst($text),
742							q{variable},
743							$tracelevel)
744							if defined $::RD_TRACE;
745
746
747
748	3033					3607	$_matched = 1;
749	3033					6289	last;
750							}
751
752
753	3817	100	66			11750	unless ( $_matched \|\| defined($score) )
754							{
755
756
757	625					1242	$_[1] = $text; # NOT SURE THIS IS NEEDED
758	625	50				1403	Parse::RecDescent::_trace(q{<>},
759							Parse::RecDescent::_tracefirst($_[1]),
760							q{variable},
761							$tracelevel)
762							if defined $::RD_TRACE;
763	625					4693	return undef;
764							}
765	3192	50	33			13955	if (!defined($return) && defined($score))
766							{
767	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
768							q{variable},
769							$tracelevel)
770							if defined $::RD_TRACE;
771	0					0	$return = $score_return;
772							}
773	3192					8523	splice @{$thisparser->{errors}}, $err_at;
	3192					11057
774	3192	50				8543	$return = $item[$#item] unless defined $return;
775	3192	50				7837	if (defined $::RD_TRACE)
776							{
777	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
778							$return . q{])}, "",
779							q{variable},
780							$tracelevel);
781	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
782							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
783							Parse::RecDescent::_tracefirst($text),
784							, q{variable},
785							$tracelevel)
786							}
787	3192					5647	$_[1] = $text;
788	3192					33903	return $return;
789							}
790
791							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
792							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function
793							{
794	4307			4307		6551	my $thisparser = $_[0];
795	23			23		257	use vars q{$tracelevel};
	23					51
	23					10141
796	4307		50			11841	local $tracelevel = ($tracelevel\|\|0)+1;
797	4307					5623	$ERRORS = 0;
798	4307					10560	my $thisrule = $thisparser->{"rules"}{"function"};
799
800	4307	50				12549	Parse::RecDescent::_trace(q{Trying rule: [function]},
801							Parse::RecDescent::_tracefirst($_[1]),
802							q{function},
803							$tracelevel)
804							if defined $::RD_TRACE;
805
806
807	4307					4468	my $err_at = @{$thisparser->{errors}};
	4307					8772
808
809	4307					6485	my $score;
810							my $score_return;
811	0					0	my $_tok;
812	4307					13872	my $return = undef;
813	4307					4992	my $_matched=0;
814	4307					4772	my $commit=0;
815	4307					6125	my @item = ();
816	4307					6335	my %item = ();
817	4307					5501	my $repeating = $_[2];
818	4307					5316	my $_noactions = $_[3];
819	4307	50				8442	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	4307					4816
	4307					8370
820	4307					6641	my $_itempos = $_[5];
821	4307	50				10527	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
822	4307					5473	my $text;
823							my $lastsep;
824	0					0	my $current_match;
825	4307					14765	my $expectation = new Parse::RecDescent::Expectation(q{function_name});
826	4307					37537	$expectation->at($_[1]);
827
828	4307					21568	my $thisline;
829	4307					19150	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
830
831
832
833	4307		33			38746	while (!$_matched && !$commit)
834							{
835
836	4307	50				9534	Parse::RecDescent::_trace(q{Trying production: [function_name '(' expr_list ')']},
837							Parse::RecDescent::_tracefirst($_[1]),
838							q{function},
839							$tracelevel)
840							if defined $::RD_TRACE;
841	4307					9607	my $thisprod = $thisrule->{"prods"}[0];
842	4307					6536	$text = $_[1];
843	4307					4599	my $_savetext;
844	4307					7580	@item = (q{function});
845	4307					8678	%item = (__RULE__ => q{function});
846	4307					5090	my $repcount = 0;
847
848
849	4307	50				8897	Parse::RecDescent::_trace(q{Trying subrule: [function_name]},
850							Parse::RecDescent::_tracefirst($text),
851							q{function},
852							$tracelevel)
853							if defined $::RD_TRACE;
854	23			23		173	if (1) { no strict qw{refs};
	23					54
	23					11321
	4307					4554
855	4307					11314	$expectation->is(q{})->at($text);
856	4307	100		4307		44025	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function_name($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	4307					8910
857							{
858
859	3817	50				8001	Parse::RecDescent::_trace(q{<>},
860							Parse::RecDescent::_tracefirst($text),
861							q{function},
862							$tracelevel)
863							if defined $::RD_TRACE;
864	3817					13148	$expectation->failed();
865	3817					15239	last;
866							}
867	490	50				3614	Parse::RecDescent::_trace(q{>>Matched subrule: [function_name]<< (return value: [}
868							. $_tok . q{]},
869
870							Parse::RecDescent::_tracefirst($text),
871							q{function},
872							$tracelevel)
873							if defined $::RD_TRACE;
874	490					1119	$item{q{function_name}} = $_tok;
875	490					1139	push @item, $_tok;
876
877							}
878
879	490	50				1090	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
880							Parse::RecDescent::_tracefirst($text),
881							q{function},
882							$tracelevel)
883							if defined $::RD_TRACE;
884	490					883	undef $lastsep;
885	490					1723	$expectation->is(q{'('})->at($text);
886
887
888	490	50	33			6158	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	490	50				8666
889							{
890	0	0				0	$text = $lastsep . $text if defined $lastsep;
891
892	0					0	$expectation->failed();
893	0	0				0	Parse::RecDescent::_trace(qq{<>},
894							Parse::RecDescent::_tracefirst($text))
895							if defined $::RD_TRACE;
896	0					0	last;
897							}
898	490					3657	$current_match = substr($text, $-[0], $+[0] - $-[0]);
899	490					1681	substr($text,0,length($current_match),q{});
900	490	50				1268	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
901							. $current_match . q{])},
902							Parse::RecDescent::_tracefirst($text))
903							if defined $::RD_TRACE;
904	490					1465	push @item, $item{__STRING1__}=$current_match;
905
906
907	490	50				1457	Parse::RecDescent::_trace(q{Trying subrule: [expr_list]},
908							Parse::RecDescent::_tracefirst($text),
909							q{function},
910							$tracelevel)
911							if defined $::RD_TRACE;
912	23			23		146	if (1) { no strict qw{refs};
	23					72
	23					33283
	490					635
913	490					1813	$expectation->is(q{expr_list})->at($text);
914	490	50		490		6228	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr_list($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	490					1129
915							{
916
917	0	0				0	Parse::RecDescent::_trace(q{<>},
918							Parse::RecDescent::_tracefirst($text),
919							q{function},
920							$tracelevel)
921							if defined $::RD_TRACE;
922	0					0	$expectation->failed();
923	0					0	last;
924							}
925	490	50				2599	Parse::RecDescent::_trace(q{>>Matched subrule: [expr_list]<< (return value: [}
926							. $_tok . q{]},
927
928							Parse::RecDescent::_tracefirst($text),
929							q{function},
930							$tracelevel)
931							if defined $::RD_TRACE;
932	490					1271	$item{q{expr_list}} = $_tok;
933	490					883	push @item, $_tok;
934
935							}
936
937	490	50				1674	Parse::RecDescent::_trace(q{Trying terminal: [')']},
938							Parse::RecDescent::_tracefirst($text),
939							q{function},
940							$tracelevel)
941							if defined $::RD_TRACE;
942	490					840	undef $lastsep;
943	490					1678	$expectation->is(q{')'})->at($text);
944
945
946	490	50	33			5667	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	490	50				4942
947							{
948	0	0				0	$text = $lastsep . $text if defined $lastsep;
949
950	0					0	$expectation->failed();
951	0	0				0	Parse::RecDescent::_trace(qq{<>},
952							Parse::RecDescent::_tracefirst($text))
953							if defined $::RD_TRACE;
954	0					0	last;
955							}
956	490					2771	$current_match = substr($text, $-[0], $+[0] - $-[0]);
957	490					1600	substr($text,0,length($current_match),q{});
958	490	50				2188	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
959							. $current_match . q{])},
960							Parse::RecDescent::_tracefirst($text))
961							if defined $::RD_TRACE;
962	490					1472	push @item, $item{__STRING2__}=$current_match;
963
964
965	490	50				1221	Parse::RecDescent::_trace(q{Trying action},
966							Parse::RecDescent::_tracefirst($text),
967							q{function},
968							$tracelevel)
969							if defined $::RD_TRACE;
970
971
972	490	50				1073	$_tok = ($_noactions) ? 0 : do {
973							#warn 'function '
974							# if $Math::Symbolic::Parser::DEBUG;
975	490					961	my $fname = $item[1];
976	490					3462	my $function;
977	490	100				1817	if (exists($Math::Symbolic::Parser::Parser_Functions{$fname})) {
978	8					17	$function = $Math::Symbolic::Parser::Parser_Functions{$fname}->($fname, @{$item[3]});
	8					51
979	8	50				27	die "Invalid function '$fname'!"
980							unless defined $function;
981							}
982							else {
983	482					1399	$function = $Math::Symbolic::Operator::Op_Symbols{ $fname };
984	482	50				1157	die "Invalid function '$fname'!"
985							unless defined $function;
986	482					4376	$function = Math::Symbolic::Operator->new(
987							{ type => $function, operands => $item[3] }
988							);
989							}
990	490					2012	$function
991							};
992	490	50				1432	unless (defined $_tok)
993							{
994	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
995							if defined $::RD_TRACE;
996	0					0	last;
997							}
998	490	50				1297	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
999							. $_tok . q{])},
1000							Parse::RecDescent::_tracefirst($text))
1001							if defined $::RD_TRACE;
1002	490					859	push @item, $_tok;
1003	490					981	$item{__ACTION1__}=$_tok;
1004
1005
1006	490	50				1121	Parse::RecDescent::_trace(q{>>Matched production: [function_name '(' expr_list ')']<<},
1007							Parse::RecDescent::_tracefirst($text),
1008							q{function},
1009							$tracelevel)
1010							if defined $::RD_TRACE;
1011
1012
1013
1014	490					630	$_matched = 1;
1015	490					1285	last;
1016							}
1017
1018
1019	4307	100	66			25827	unless ( $_matched \|\| defined($score) )
1020							{
1021
1022
1023	3817					6480	$_[1] = $text; # NOT SURE THIS IS NEEDED
1024	3817	50				7452	Parse::RecDescent::_trace(q{<>},
1025							Parse::RecDescent::_tracefirst($_[1]),
1026							q{function},
1027							$tracelevel)
1028							if defined $::RD_TRACE;
1029	3817					27070	return undef;
1030							}
1031	490	50	33			2270	if (!defined($return) && defined($score))
1032							{
1033	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1034							q{function},
1035							$tracelevel)
1036							if defined $::RD_TRACE;
1037	0					0	$return = $score_return;
1038							}
1039	490					699	splice @{$thisparser->{errors}}, $err_at;
	490					1206
1040	490	50				2883	$return = $item[$#item] unless defined $return;
1041	490	50				1277	if (defined $::RD_TRACE)
1042							{
1043	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1044							$return . q{])}, "",
1045							q{function},
1046							$tracelevel);
1047	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1048							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1049							Parse::RecDescent::_tracefirst($text),
1050							, q{function},
1051							$tracelevel)
1052							}
1053	490					1406	$_[1] = $text;
1054	490					6122	return $return;
1055							}
1056
1057							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1058							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::number
1059							{
1060	6093			6093		12688	my $thisparser = $_[0];
1061	23			23		160	use vars q{$tracelevel};
	23					59
	23					29197
1062	6093		50			15702	local $tracelevel = ($tracelevel\|\|0)+1;
1063	6093					7606	$ERRORS = 0;
1064	6093					12749	my $thisrule = $thisparser->{"rules"}{"number"};
1065
1066	6093	50				11934	Parse::RecDescent::_trace(q{Trying rule: [number]},
1067							Parse::RecDescent::_tracefirst($_[1]),
1068							q{number},
1069							$tracelevel)
1070							if defined $::RD_TRACE;
1071
1072
1073	6093					6708	my $err_at = @{$thisparser->{errors}};
	6093					16182
1074
1075	6093					8058	my $score;
1076							my $score_return;
1077	0					0	my $_tok;
1078	6093					7160	my $return = undef;
1079	6093					7841	my $_matched=0;
1080	6093					7030	my $commit=0;
1081	6093					8523	my @item = ();
1082	6093					9324	my %item = ();
1083	6093					7698	my $repeating = $_[2];
1084	6093					7629	my $_noactions = $_[3];
1085	6093	50				12109	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	6093					6936
	6093					11875
1086	6093					8679	my $_itempos = $_[5];
1087	6093	50				19083	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1088	6093					7553	my $text;
1089							my $lastsep;
1090	0					0	my $current_match;
1091	6093					19450	my $expectation = new Parse::RecDescent::Expectation(q{/([+-]?)(?=\\d\|\\.\\d)\\d(\\.\\d)?([Ee]([+-]?\\d+))?/});
1092	6093					48475	$expectation->at($_[1]);
1093
1094	6093					25304	my $thisline;
1095	6093					25385	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1096
1097
1098
1099	6093		33			58039	while (!$_matched && !$commit)
1100							{
1101
1102	6093	50				12058	Parse::RecDescent::_trace(q{Trying production: [/([+-]?)(?=\\d\|\\.\\d)\\d(\\.\\d)?([Ee]([+-]?\\d+))?/]},
1103							Parse::RecDescent::_tracefirst($_[1]),
1104							q{number},
1105							$tracelevel)
1106							if defined $::RD_TRACE;
1107	6093					13501	my $thisprod = $thisrule->{"prods"}[0];
1108	6093					8881	$text = $_[1];
1109	6093					6453	my $_savetext;
1110	6093					11196	@item = (q{number});
1111	6093					18457	%item = (__RULE__ => q{number});
1112	6093					9339	my $repcount = 0;
1113
1114
1115	6093	50				12178	Parse::RecDescent::_trace(q{Trying terminal: [/([+-]?)(?=\\d\|\\.\\d)\\d(\\.\\d)?([Ee]([+-]?\\d+))?/]}, Parse::RecDescent::_tracefirst($text),
1116							q{number},
1117							$tracelevel)
1118							if defined $::RD_TRACE;
1119	6093					7864	undef $lastsep;
1120	6093					17702	$expectation->is(q{})->at($text);
1121
1122
1123	6093	50	66			62023	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:([+-]?)(?=\d\|\.\d)\d(\.\d)?([Ee]([+-]?\d+))?)/)
	6093	100				62574
1124							{
1125	4307	50				17876	$text = $lastsep . $text if defined $lastsep;
1126	4307					13788	$expectation->failed();
1127	4307	50				19668	Parse::RecDescent::_trace(q{<>},
1128							Parse::RecDescent::_tracefirst($text))
1129							if defined $::RD_TRACE;
1130
1131	4307					8974	last;
1132							}
1133	1786					8773	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1134	1786					5256	substr($text,0,length($current_match),q{});
1135	1786	50				4079	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1136							. $current_match . q{])},
1137							Parse::RecDescent::_tracefirst($text))
1138							if defined $::RD_TRACE;
1139	1786					10734	push @item, $item{__PATTERN1__}=$current_match;
1140
1141
1142	1786	50				4701	Parse::RecDescent::_trace(q{Trying action},
1143							Parse::RecDescent::_tracefirst($text),
1144							q{number},
1145							$tracelevel)
1146							if defined $::RD_TRACE;
1147
1148
1149	1786	50				3380	$_tok = ($_noactions) ? 0 : do {
1150							#warn 'number '
1151							# if $Math::Symbolic::Parser::DEBUG;
1152	1786					8361	Math::Symbolic::Constant->new($item[1])
1153							};
1154	1786	50				4239	unless (defined $_tok)
1155							{
1156	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1157							if defined $::RD_TRACE;
1158	0					0	last;
1159							}
1160	1786	50				3801	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1161							. $_tok . q{])},
1162							Parse::RecDescent::_tracefirst($text))
1163							if defined $::RD_TRACE;
1164	1786					2370	push @item, $_tok;
1165	1786					3320	$item{__ACTION1__}=$_tok;
1166
1167
1168	1786	50				3793	Parse::RecDescent::_trace(q{>>Matched production: [/([+-]?)(?=\\d\|\\.\\d)\\d(\\.\\d)?([Ee]([+-]?\\d+))?/]<<},
1169							Parse::RecDescent::_tracefirst($text),
1170							q{number},
1171							$tracelevel)
1172							if defined $::RD_TRACE;
1173
1174
1175
1176	1786					2082	$_matched = 1;
1177	1786					3554	last;
1178							}
1179
1180
1181	6093	100	66			29501	unless ( $_matched \|\| defined($score) )
1182							{
1183
1184
1185	4307					6940	$_[1] = $text; # NOT SURE THIS IS NEEDED
1186	4307	50				9249	Parse::RecDescent::_trace(q{<>},
1187							Parse::RecDescent::_tracefirst($_[1]),
1188							q{number},
1189							$tracelevel)
1190							if defined $::RD_TRACE;
1191	4307					32573	return undef;
1192							}
1193	1786	50	33			8449	if (!defined($return) && defined($score))
1194							{
1195	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1196							q{number},
1197							$tracelevel)
1198							if defined $::RD_TRACE;
1199	0					0	$return = $score_return;
1200							}
1201	1786					2237	splice @{$thisparser->{errors}}, $err_at;
	1786					4499
1202	1786	50				4812	$return = $item[$#item] unless defined $return;
1203	1786	50				4021	if (defined $::RD_TRACE)
1204							{
1205	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1206							$return . q{])}, "",
1207							q{number},
1208							$tracelevel);
1209	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1210							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1211							Parse::RecDescent::_tracefirst($text),
1212							, q{number},
1213							$tracelevel)
1214							}
1215	1786					3252	$_[1] = $text;
1216	1786					15216	return $return;
1217							}
1218
1219							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1220							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::multiplication
1221							{
1222	2262			2262		3685	my $thisparser = $_[0];
1223	23			23		207	use vars q{$tracelevel};
	23					69
	23					14849
1224	2262		50			6536	local $tracelevel = ($tracelevel\|\|0)+1;
1225	2262					3121	$ERRORS = 0;
1226	2262					5132	my $thisrule = $thisparser->{"rules"}{"multiplication"};
1227
1228	2262	50				4856	Parse::RecDescent::_trace(q{Trying rule: [multiplication]},
1229							Parse::RecDescent::_tracefirst($_[1]),
1230							q{multiplication},
1231							$tracelevel)
1232							if defined $::RD_TRACE;
1233
1234
1235	2262					2992	my $err_at = @{$thisparser->{errors}};
	2262					4498
1236
1237	2262					3101	my $score;
1238							my $score_return;
1239	0					0	my $_tok;
1240	2262					3493	my $return = undef;
1241	2262					2932	my $_matched=0;
1242	2262					2855	my $commit=0;
1243	2262					3515	my @item = ();
1244	2262					3455	my %item = ();
1245	2262					2946	my $repeating = $_[2];
1246	2262					2909	my $_noactions = $_[3];
1247	2262	50				5620	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2262					2593
	2262					5695
1248	2262					3323	my $_itempos = $_[5];
1249	2262	50				10624	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1250	2262					3984	my $text;
1251							my $lastsep;
1252	0					0	my $current_match;
1253	2262					7596	my $expectation = new Parse::RecDescent::Expectation(q{});
1254	2262					18481	$expectation->at($_[1]);
1255
1256	2262					9644	my $thisline;
1257	2262					9690	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1258
1259
1260
1261	2262		33			21822	while (!$_matched && !$commit)
1262							{
1263
1264	2262	50				4849	Parse::RecDescent::_trace(q{Trying production: []},
1265							Parse::RecDescent::_tracefirst($_[1]),
1266							q{multiplication},
1267							$tracelevel)
1268							if defined $::RD_TRACE;
1269	2262					5964	my $thisprod = $thisrule->{"prods"}[0];
1270	2262					3488	$text = $_[1];
1271	2262					2747	my $_savetext;
1272	2262					4400	@item = (q{multiplication});
1273	2262					4827	%item = (__RULE__ => q{multiplication});
1274	2262					2789	my $repcount = 0;
1275
1276
1277	2262	50				4899	Parse::RecDescent::_trace(q{Trying operator: []},
1278							Parse::RecDescent::_tracefirst($text),
1279							q{multiplication},
1280							$tracelevel)
1281							if defined $::RD_TRACE;
1282	2262					6215	$expectation->is(q{})->at($text);
1283
1284	2262					33006	$_tok = undef;
1285	2262					2772	OPLOOP: while (1)
1286							{
1287	2262					2717	$repcount = 0;
1288	2262					3000	my @item;
1289							my %item;
1290
1291							# MATCH LEFTARG
1292
1293	2262	50				4734	Parse::RecDescent::_trace(q{Trying subrule: [exp]},
1294							Parse::RecDescent::_tracefirst($text),
1295							q{multiplication},
1296							$tracelevel)
1297							if defined $::RD_TRACE;
1298	23			23		155	if (1) { no strict qw{refs};
	23					52
	23					6650
	2262					2773
1299	2262					8177	$expectation->is(q{exp})->at($text);
1300	2262	50		2262		24222	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::exp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2262					4728
1301							{
1302
1303	0	0				0	Parse::RecDescent::_trace(q{<>},
1304							Parse::RecDescent::_tracefirst($text),
1305							q{multiplication},
1306							$tracelevel)
1307							if defined $::RD_TRACE;
1308	0					0	$expectation->failed();
1309	0					0	last;
1310							}
1311	2262	50				10772	Parse::RecDescent::_trace(q{>>Matched subrule: [exp]<< (return value: [}
1312							. $_tok . q{]},
1313
1314							Parse::RecDescent::_tracefirst($text),
1315							q{multiplication},
1316							$tracelevel)
1317							if defined $::RD_TRACE;
1318	2262					4676	$item{q{exp}} = $_tok;
1319	2262					4321	push @item, $_tok;
1320
1321							}
1322
1323
1324
1325	2262					3158	$repcount++;
1326
1327	2262					3871	my $savetext = $text;
1328	2262					2610	my $backtrack;
1329
1330							# MATCH (OP RIGHTARG)(s)
1331	2262					5426	while ($repcount < 100000000)
1332							{
1333	2907					4080	$backtrack = 0;
1334
1335	2907	50				5689	Parse::RecDescent::_trace(q{Trying subrule: [mult_op]},
1336							Parse::RecDescent::_tracefirst($text),
1337							q{multiplication},
1338							$tracelevel)
1339							if defined $::RD_TRACE;
1340	23			23		136	if (1) { no strict qw{refs};
	23					49
	23					5260
	2907					4171
1341	2907					10622	$expectation->is(q{mult_op})->at($text);
1342	2907	100		2907		42912	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::mult_op($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2907					6828
1343							{
1344
1345	2262	50				4532	Parse::RecDescent::_trace(q{<>},
1346							Parse::RecDescent::_tracefirst($text),
1347							q{multiplication},
1348							$tracelevel)
1349							if defined $::RD_TRACE;
1350	2262					6694	$expectation->failed();
1351	2262					20182	last;
1352							}
1353	645	50				2952	Parse::RecDescent::_trace(q{>>Matched subrule: [mult_op]<< (return value: [}
1354							. $_tok . q{]},
1355
1356							Parse::RecDescent::_tracefirst($text),
1357							q{multiplication},
1358							$tracelevel)
1359							if defined $::RD_TRACE;
1360	645					1731	$item{q{mult_op}} = $_tok;
1361	645					1195	push @item, $_tok;
1362
1363							}
1364
1365	645					1025	$backtrack=1;
1366
1367
1368	645	50				1584	Parse::RecDescent::_trace(q{Trying subrule: [exp]},
1369							Parse::RecDescent::_tracefirst($text),
1370							q{multiplication},
1371							$tracelevel)
1372							if defined $::RD_TRACE;
1373	23			23		137	if (1) { no strict qw{refs};
	23					56
	23					28523
	645					861
1374	645					2216	$expectation->is(q{exp})->at($text);
1375	645	50		645		7696	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::exp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	645					1462
1376							{
1377
1378	0	0				0	Parse::RecDescent::_trace(q{<>},
1379							Parse::RecDescent::_tracefirst($text),
1380							q{multiplication},
1381							$tracelevel)
1382							if defined $::RD_TRACE;
1383	0					0	$expectation->failed();
1384	0					0	last;
1385							}
1386	645	50				3351	Parse::RecDescent::_trace(q{>>Matched subrule: [exp]<< (return value: [}
1387							. $_tok . q{]},
1388
1389							Parse::RecDescent::_tracefirst($text),
1390							q{multiplication},
1391							$tracelevel)
1392							if defined $::RD_TRACE;
1393	645					1465	$item{q{exp}} = $_tok;
1394	645					1245	push @item, $_tok;
1395
1396							}
1397
1398	645					1040	$savetext = $text;
1399	645					1840	$repcount++;
1400							}
1401	2262					7996	$text = $savetext;
1402	2262	50				5186	pop @item if $backtrack;
1403
1404	2262	50				5321	unless (@item) { undef $_tok; last }
	0					0
	0					0
1405	2262					5470	$_tok = [ @item ];
1406
1407	2262					5770	last;
1408							} # end of OPLOOP
1409
1410	2262	50				13209	unless ($repcount>=1)
1411							{
1412	0	0				0	Parse::RecDescent::_trace(q{<]>>},
1413							Parse::RecDescent::_tracefirst($text),
1414							q{multiplication},
1415							$tracelevel)
1416							if defined $::RD_TRACE;
1417	0					0	$expectation->failed();
1418	0					0	last;
1419							}
1420	2262	50				4786	Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [}
1421	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
1422							Parse::RecDescent::_tracefirst($text),
1423							q{multiplication},
1424							$tracelevel)
1425							if defined $::RD_TRACE;
1426
1427	2262		50			8074	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
1428
1429	2262	50				4752	Parse::RecDescent::_trace(q{Trying action},
1430							Parse::RecDescent::_tracefirst($text),
1431							q{multiplication},
1432							$tracelevel)
1433							if defined $::RD_TRACE;
1434
1435
1436	2262	50				5169	$_tok = ($_noactions) ? 0 : do {
1437							#warn 'multiplication '
1438							# if $Math::Symbolic::Parser::DEBUG;
1439	2262	100				3154	if (@{$item[1]} == 1) {
	2262					5668
1440	1647					3310	$item[1][0]
1441							}
1442							else {
1443	615					1357	my @it = @{$item[1]};
	615					2257
1444	615					1251	my $tree = shift @it;
1445	615					2665	while (@it) {
1446	645					4320	$tree = Math::Symbolic::Operator->new(
1447							shift(@it), $tree, shift(@it)
1448							);
1449							}
1450	615					1570	$tree;
1451							}
1452							};
1453	2262	50				5546	unless (defined $_tok)
1454							{
1455	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1456							if defined $::RD_TRACE;
1457	0					0	last;
1458							}
1459	2262	50				4564	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1460							. $_tok . q{])},
1461							Parse::RecDescent::_tracefirst($text))
1462							if defined $::RD_TRACE;
1463	2262					3234	push @item, $_tok;
1464	2262					4151	$item{__ACTION1__}=$_tok;
1465
1466
1467	2262	50				4414	Parse::RecDescent::_trace(q{>>Matched production: []<<},
1468							Parse::RecDescent::_tracefirst($text),
1469							q{multiplication},
1470							$tracelevel)
1471							if defined $::RD_TRACE;
1472
1473
1474
1475	2262					2992	$_matched = 1;
1476	2262					3642	last;
1477							}
1478
1479
1480	2262	50	33			6194	unless ( $_matched \|\| defined($score) )
1481							{
1482
1483
1484	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
1485	0	0				0	Parse::RecDescent::_trace(q{<>},
1486							Parse::RecDescent::_tracefirst($_[1]),
1487							q{multiplication},
1488							$tracelevel)
1489							if defined $::RD_TRACE;
1490	0					0	return undef;
1491							}
1492	2262	50	33			10055	if (!defined($return) && defined($score))
1493							{
1494	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1495							q{multiplication},
1496							$tracelevel)
1497							if defined $::RD_TRACE;
1498	0					0	$return = $score_return;
1499							}
1500	2262					2842	splice @{$thisparser->{errors}}, $err_at;
	2262					5454
1501	2262	50				6151	$return = $item[$#item] unless defined $return;
1502	2262	50				4871	if (defined $::RD_TRACE)
1503							{
1504	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1505							$return . q{])}, "",
1506							q{multiplication},
1507							$tracelevel);
1508	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1509							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1510							Parse::RecDescent::_tracefirst($text),
1511							, q{multiplication},
1512							$tracelevel)
1513							}
1514	2262					3860	$_[1] = $text;
1515	2262					20799	return $return;
1516							}
1517
1518							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1519							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::parse
1520							{
1521	355			355		22294	my $thisparser = $_[0];
1522	23			23		169	use vars q{$tracelevel};
	23					55
	23					10261
1523	355		100			2083	local $tracelevel = ($tracelevel\|\|0)+1;
1524	355					959	$ERRORS = 0;
1525	355					1005	my $thisrule = $thisparser->{"rules"}{"parse"};
1526
1527	355	50				1055	Parse::RecDescent::_trace(q{Trying rule: [parse]},
1528							Parse::RecDescent::_tracefirst($_[1]),
1529							q{parse},
1530							$tracelevel)
1531							if defined $::RD_TRACE;
1532
1533
1534	355					495	my $err_at = @{$thisparser->{errors}};
	355					776
1535
1536	355					657	my $score;
1537							my $score_return;
1538	0					0	my $_tok;
1539	355					566	my $return = undef;
1540	355					532	my $_matched=0;
1541	355					518	my $commit=0;
1542	355					727	my @item = ();
1543	355					987	my %item = ();
1544	355					525	my $repeating = $_[2];
1545	355					570	my $_noactions = $_[3];
1546	355	50				944	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	355					517
	355					1063
1547	355					1567	my $_itempos = $_[5];
1548	355	50				1209	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1549	355					569	my $text;
1550							my $lastsep;
1551	0					0	my $current_match;
1552	355					1813	my $expectation = new Parse::RecDescent::Expectation(q{expr, or //});
1553	355					3678	$expectation->at($_[1]);
1554
1555	355					1797	my $thisline;
1556	355					2076	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1557
1558
1559
1560	355		33			4308	while (!$_matched && !$commit)
1561							{
1562
1563	355	50				981	Parse::RecDescent::_trace(q{Trying production: [expr /^\\Z/]},
1564							Parse::RecDescent::_tracefirst($_[1]),
1565							q{parse},
1566							$tracelevel)
1567							if defined $::RD_TRACE;
1568	355					1251	my $thisprod = $thisrule->{"prods"}[0];
1569	355					629	$text = $_[1];
1570	355					767	my $_savetext;
1571	355					830	@item = (q{parse});
1572	355					1043	%item = (__RULE__ => q{parse});
1573	355					544	my $repcount = 0;
1574
1575
1576	355	50				925	Parse::RecDescent::_trace(q{Trying subrule: [expr]},
1577							Parse::RecDescent::_tracefirst($text),
1578							q{parse},
1579							$tracelevel)
1580							if defined $::RD_TRACE;
1581	23			23		187	if (1) { no strict qw{refs};
	23					57
	23					34246
	355					459
1582	355					1214	$expectation->is(q{})->at($text);
1583	355	50		355		3926	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	355					1058
1584							{
1585
1586	0	0				0	Parse::RecDescent::_trace(q{<>},
1587							Parse::RecDescent::_tracefirst($text),
1588							q{parse},
1589							$tracelevel)
1590							if defined $::RD_TRACE;
1591	0					0	$expectation->failed();
1592	0					0	last;
1593							}
1594	355	50				1812	Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
1595							. $_tok . q{]},
1596
1597							Parse::RecDescent::_tracefirst($text),
1598							q{parse},
1599							$tracelevel)
1600							if defined $::RD_TRACE;
1601	355					840	$item{q{expr}} = $_tok;
1602	355					697	push @item, $_tok;
1603
1604							}
1605
1606	355	50				803	Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
1607							q{parse},
1608							$tracelevel)
1609							if defined $::RD_TRACE;
1610	355					539	undef $lastsep;
1611	355					1585	$expectation->is(q{/^\\Z/})->at($text);
1612
1613
1614	355	50	66			4441	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:^\Z)/)
	355	100				3455
1615							{
1616	1	50				4	$text = $lastsep . $text if defined $lastsep;
1617	1					4	$expectation->failed();
1618	1	50				9	Parse::RecDescent::_trace(q{<>},
1619							Parse::RecDescent::_tracefirst($text))
1620							if defined $::RD_TRACE;
1621
1622	1					3	last;
1623							}
1624	354					2126	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1625	354					1113	substr($text,0,length($current_match),q{});
1626	354	50				864	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1627							. $current_match . q{])},
1628							Parse::RecDescent::_tracefirst($text))
1629							if defined $::RD_TRACE;
1630	354					1007	push @item, $item{__PATTERN1__}=$current_match;
1631
1632
1633	354	50				901	Parse::RecDescent::_trace(q{Trying action},
1634							Parse::RecDescent::_tracefirst($text),
1635							q{parse},
1636							$tracelevel)
1637							if defined $::RD_TRACE;
1638
1639
1640	354	50				721	$_tok = ($_noactions) ? 0 : do {
1641	354					5369	$return = $item[1]
1642							};
1643	354	50				861	unless (defined $_tok)
1644							{
1645	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1646							if defined $::RD_TRACE;
1647	0					0	last;
1648							}
1649	354	50				899	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1650							. $_tok . q{])},
1651							Parse::RecDescent::_tracefirst($text))
1652							if defined $::RD_TRACE;
1653	354					624	push @item, $_tok;
1654	354					677	$item{__ACTION1__}=$_tok;
1655
1656
1657	354	50				753	Parse::RecDescent::_trace(q{>>Matched production: [expr /^\\Z/]<<},
1658							Parse::RecDescent::_tracefirst($text),
1659							q{parse},
1660							$tracelevel)
1661							if defined $::RD_TRACE;
1662
1663
1664
1665	354					536	$_matched = 1;
1666	354					821	last;
1667							}
1668
1669
1670	355		66			953	while (!$_matched && !$commit)
1671							{
1672
1673	1	50				3	Parse::RecDescent::_trace(q{Trying production: [//]},
1674							Parse::RecDescent::_tracefirst($_[1]),
1675							q{parse},
1676							$tracelevel)
1677							if defined $::RD_TRACE;
1678	1					4	my $thisprod = $thisrule->{"prods"}[1];
1679	1					2	$text = $_[1];
1680	1					2	my $_savetext;
1681	1					3	@item = (q{parse});
1682	1					4	%item = (__RULE__ => q{parse});
1683	1					2	my $repcount = 0;
1684
1685
1686	1	50				3	Parse::RecDescent::_trace(q{Trying terminal: [//]}, Parse::RecDescent::_tracefirst($text),
1687							q{parse},
1688							$tracelevel)
1689							if defined $::RD_TRACE;
1690	1					1	undef $lastsep;
1691	1					4	$expectation->is(q{})->at($text);
1692
1693
1694	1	50	33			26	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:)/)
	1	50				11
1695							{
1696	0	0				0	$text = $lastsep . $text if defined $lastsep;
1697	0					0	$expectation->failed();
1698	0	0				0	Parse::RecDescent::_trace(q{<>},
1699							Parse::RecDescent::_tracefirst($text))
1700							if defined $::RD_TRACE;
1701
1702	0					0	last;
1703							}
1704	1					6	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1705	1					4	substr($text,0,length($current_match),q{});
1706	1	50				3	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1707							. $current_match . q{])},
1708							Parse::RecDescent::_tracefirst($text))
1709							if defined $::RD_TRACE;
1710	1					3	push @item, $item{__PATTERN1__}=$current_match;
1711
1712
1713	1	50				3	Parse::RecDescent::_trace(q{Trying action},
1714							Parse::RecDescent::_tracefirst($text),
1715							q{parse},
1716							$tracelevel)
1717							if defined $::RD_TRACE;
1718
1719
1720	1	50				3	$_tok = ($_noactions) ? 0 : do {undef};
	1					2
1721	1	50				4	unless (defined $_tok)
1722							{
1723	1	50				3	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1724							if defined $::RD_TRACE;
1725	1					2	last;
1726							}
1727	0	0				0	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1728							. $_tok . q{])},
1729							Parse::RecDescent::_tracefirst($text))
1730							if defined $::RD_TRACE;
1731	0					0	push @item, $_tok;
1732	0					0	$item{__ACTION1__}=$_tok;
1733
1734
1735	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: [//]<<},
1736							Parse::RecDescent::_tracefirst($text),
1737							q{parse},
1738							$tracelevel)
1739							if defined $::RD_TRACE;
1740
1741
1742
1743	0					0	$_matched = 1;
1744	0					0	last;
1745							}
1746
1747
1748	355	100	66			949	unless ( $_matched \|\| defined($score) )
1749							{
1750
1751
1752	1					1	$_[1] = $text; # NOT SURE THIS IS NEEDED
1753	1	50				4	Parse::RecDescent::_trace(q{<>},
1754							Parse::RecDescent::_tracefirst($_[1]),
1755							q{parse},
1756							$tracelevel)
1757							if defined $::RD_TRACE;
1758	1					9	return undef;
1759							}
1760	354	50	33			1020	if (!defined($return) && defined($score))
1761							{
1762	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1763							q{parse},
1764							$tracelevel)
1765							if defined $::RD_TRACE;
1766	0					0	$return = $score_return;
1767							}
1768	354					485	splice @{$thisparser->{errors}}, $err_at;
	354					875
1769	354	50				834	$return = $item[$#item] unless defined $return;
1770	354	50				914	if (defined $::RD_TRACE)
1771							{
1772	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1773							$return . q{])}, "",
1774							q{parse},
1775							$tracelevel);
1776	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1777							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1778							Parse::RecDescent::_tracefirst($text),
1779							, q{parse},
1780							$tracelevel)
1781							}
1782	354					752	$_[1] = $text;
1783	354					3468	return $return;
1784							}
1785
1786							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1787							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::addition
1788							{
1789	1772			1772		7802	my $thisparser = $_[0];
1790	23			23		163	use vars q{$tracelevel};
	23					48
	23					10684
1791	1772		50			7020	local $tracelevel = ($tracelevel\|\|0)+1;
1792	1772					2800	$ERRORS = 0;
1793	1772					4171	my $thisrule = $thisparser->{"rules"}{"addition"};
1794
1795	1772	50				7364	Parse::RecDescent::_trace(q{Trying rule: [addition]},
1796							Parse::RecDescent::_tracefirst($_[1]),
1797							q{addition},
1798							$tracelevel)
1799							if defined $::RD_TRACE;
1800
1801
1802	1772					2174	my $err_at = @{$thisparser->{errors}};
	1772					3742
1803
1804	1772					2603	my $score;
1805							my $score_return;
1806	0					0	my $_tok;
1807	1772					2575	my $return = undef;
1808	1772					2351	my $_matched=0;
1809	1772					2540	my $commit=0;
1810	1772					6447	my @item = ();
1811	1772					2756	my %item = ();
1812	1772					2185	my $repeating = $_[2];
1813	1772					2549	my $_noactions = $_[3];
1814	1772	50				4112	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	1772					2277
	1772					3740
1815	1772					2909	my $_itempos = $_[5];
1816	1772	50				5054	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1817	1772					2298	my $text;
1818							my $lastsep;
1819	0					0	my $current_match;
1820	1772					6659	my $expectation = new Parse::RecDescent::Expectation(q{});
1821	1772					14028	$expectation->at($_[1]);
1822
1823	1772					7978	my $thisline;
1824	1772					7558	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1825
1826
1827
1828	1772		33			17534	while (!$_matched && !$commit)
1829							{
1830
1831	1772	50				4162	Parse::RecDescent::_trace(q{Trying production: []},
1832							Parse::RecDescent::_tracefirst($_[1]),
1833							q{addition},
1834							$tracelevel)
1835							if defined $::RD_TRACE;
1836	1772					4745	my $thisprod = $thisrule->{"prods"}[0];
1837	1772					2809	$text = $_[1];
1838	1772					2105	my $_savetext;
1839	1772					3323	@item = (q{addition});
1840	1772					4308	%item = (__RULE__ => q{addition});
1841	1772					2831	my $repcount = 0;
1842
1843
1844	1772	50				3955	Parse::RecDescent::_trace(q{Trying operator: []},
1845							Parse::RecDescent::_tracefirst($text),
1846							q{addition},
1847							$tracelevel)
1848							if defined $::RD_TRACE;
1849	1772					4952	$expectation->is(q{})->at($text);
1850
1851	1772					11707	$_tok = undef;
1852	1772					2081	OPLOOP: while (1)
1853							{
1854	1772					2304	$repcount = 0;
1855	1772					2527	my @item;
1856							my %item;
1857
1858							# MATCH LEFTARG
1859
1860	1772	50				3564	Parse::RecDescent::_trace(q{Trying subrule: [multiplication]},
1861							Parse::RecDescent::_tracefirst($text),
1862							q{addition},
1863							$tracelevel)
1864							if defined $::RD_TRACE;
1865	23			23		145	if (1) { no strict qw{refs};
	23					58
	23					6956
	1772					2034
1866	1772					4695	$expectation->is(q{multiplication})->at($text);
1867	1772	50		1772		19280	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::multiplication($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	1772					4246
1868							{
1869
1870	0	0				0	Parse::RecDescent::_trace(q{<>},
1871							Parse::RecDescent::_tracefirst($text),
1872							q{addition},
1873							$tracelevel)
1874							if defined $::RD_TRACE;
1875	0					0	$expectation->failed();
1876	0					0	last;
1877							}
1878	1772	50				8096	Parse::RecDescent::_trace(q{>>Matched subrule: [multiplication]<< (return value: [}
1879							. $_tok . q{]},
1880
1881							Parse::RecDescent::_tracefirst($text),
1882							q{addition},
1883							$tracelevel)
1884							if defined $::RD_TRACE;
1885	1772					3918	$item{q{multiplication}} = $_tok;
1886	1772					3271	push @item, $_tok;
1887
1888							}
1889
1890
1891
1892	1772					2733	$repcount++;
1893
1894	1772					2837	my $savetext = $text;
1895	1772					2415	my $backtrack;
1896
1897							# MATCH (OP RIGHTARG)(s)
1898	1772					4122	while ($repcount < 100000000)
1899							{
1900	2262					3086	$backtrack = 0;
1901
1902	2262	50				4583	Parse::RecDescent::_trace(q{Trying subrule: [add_op]},
1903							Parse::RecDescent::_tracefirst($text),
1904							q{addition},
1905							$tracelevel)
1906							if defined $::RD_TRACE;
1907	23			23		140	if (1) { no strict qw{refs};
	23					55
	23					5231
	2262					2723
1908	2262					7373	$expectation->is(q{add_op})->at($text);
1909	2262	100		2262		27374	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::add_op($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2262					5202
1910							{
1911
1912	1772	50				4098	Parse::RecDescent::_trace(q{<>},
1913							Parse::RecDescent::_tracefirst($text),
1914							q{addition},
1915							$tracelevel)
1916							if defined $::RD_TRACE;
1917	1772					6009	$expectation->failed();
1918	1772					15806	last;
1919							}
1920	490	50				2030	Parse::RecDescent::_trace(q{>>Matched subrule: [add_op]<< (return value: [}
1921							. $_tok . q{]},
1922
1923							Parse::RecDescent::_tracefirst($text),
1924							q{addition},
1925							$tracelevel)
1926							if defined $::RD_TRACE;
1927	490					1300	$item{q{add_op}} = $_tok;
1928	490					1059	push @item, $_tok;
1929
1930							}
1931
1932	490					806	$backtrack=1;
1933
1934
1935	490	50				1222	Parse::RecDescent::_trace(q{Trying subrule: [multiplication]},
1936							Parse::RecDescent::_tracefirst($text),
1937							q{addition},
1938							$tracelevel)
1939							if defined $::RD_TRACE;
1940	23			23		131	if (1) { no strict qw{refs};
	23					51
	23					24965
	490					716
1941	490					1727	$expectation->is(q{multiplication})->at($text);
1942	490	50		490		5787	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::multiplication($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	490					1251
1943							{
1944
1945	0	0				0	Parse::RecDescent::_trace(q{<>},
1946							Parse::RecDescent::_tracefirst($text),
1947							q{addition},
1948							$tracelevel)
1949							if defined $::RD_TRACE;
1950	0					0	$expectation->failed();
1951	0					0	last;
1952							}
1953	490	50				2659	Parse::RecDescent::_trace(q{>>Matched subrule: [multiplication]<< (return value: [}
1954							. $_tok . q{]},
1955
1956							Parse::RecDescent::_tracefirst($text),
1957							q{addition},
1958							$tracelevel)
1959							if defined $::RD_TRACE;
1960	490					1095	$item{q{multiplication}} = $_tok;
1961	490					928	push @item, $_tok;
1962
1963							}
1964
1965	490					807	$savetext = $text;
1966	490					1494	$repcount++;
1967							}
1968	1772					6367	$text = $savetext;
1969	1772	50				3871	pop @item if $backtrack;
1970
1971	1772	50				4351	unless (@item) { undef $_tok; last }
	0					0
	0					0
1972	1772					4728	$_tok = [ @item ];
1973
1974	1772					4513	last;
1975							} # end of OPLOOP
1976
1977	1772	50				4733	unless ($repcount>=1)
1978							{
1979	0	0				0	Parse::RecDescent::_trace(q{<]>>},
1980							Parse::RecDescent::_tracefirst($text),
1981							q{addition},
1982							$tracelevel)
1983							if defined $::RD_TRACE;
1984	0					0	$expectation->failed();
1985	0					0	last;
1986							}
1987	1772	50				4152	Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [}
1988	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
1989							Parse::RecDescent::_tracefirst($text),
1990							q{addition},
1991							$tracelevel)
1992							if defined $::RD_TRACE;
1993
1994	1772		50			6061	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
1995
1996	1772	50				3560	Parse::RecDescent::_trace(q{Trying action},
1997							Parse::RecDescent::_tracefirst($text),
1998							q{addition},
1999							$tracelevel)
2000							if defined $::RD_TRACE;
2001
2002
2003	1772	50				4565	$_tok = ($_noactions) ? 0 : do {
2004							#warn 'addition '
2005							# if $Math::Symbolic::Parser::DEBUG;
2006	1772	100				2532	if (@{$item[1]} == 1) {
	1772					5086
2007	1357					3319	$item[1][0]
2008							}
2009							else {
2010	415					564	my @it = @{$item[1]};
	415					1289
2011	415					815	my $tree = shift @it;
2012	415					969	while (@it) {
2013	490					2871	$tree = Math::Symbolic::Operator->new(
2014							shift(@it), $tree, shift(@it)
2015							);
2016							}
2017	415					1107	$tree;
2018							}
2019							};
2020	1772	50				5045	unless (defined $_tok)
2021							{
2022	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2023							if defined $::RD_TRACE;
2024	0					0	last;
2025							}
2026	1772	50				3862	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2027							. $_tok . q{])},
2028							Parse::RecDescent::_tracefirst($text))
2029							if defined $::RD_TRACE;
2030	1772					2604	push @item, $_tok;
2031	1772					3343	$item{__ACTION1__}=$_tok;
2032
2033
2034	1772	50				3935	Parse::RecDescent::_trace(q{>>Matched production: []<<},
2035							Parse::RecDescent::_tracefirst($text),
2036							q{addition},
2037							$tracelevel)
2038							if defined $::RD_TRACE;
2039
2040
2041
2042	1772					2567	$_matched = 1;
2043	1772					3371	last;
2044							}
2045
2046
2047	1772	50	33			5124	unless ( $_matched \|\| defined($score) )
2048							{
2049
2050
2051	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
2052	0	0				0	Parse::RecDescent::_trace(q{<>},
2053							Parse::RecDescent::_tracefirst($_[1]),
2054							q{addition},
2055							$tracelevel)
2056							if defined $::RD_TRACE;
2057	0					0	return undef;
2058							}
2059	1772	50	33			14214	if (!defined($return) && defined($score))
2060							{
2061	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2062							q{addition},
2063							$tracelevel)
2064							if defined $::RD_TRACE;
2065	0					0	$return = $score_return;
2066							}
2067	1772					2137	splice @{$thisparser->{errors}}, $err_at;
	1772					3972
2068	1772	50				5293	$return = $item[$#item] unless defined $return;
2069	1772	50				3964	if (defined $::RD_TRACE)
2070							{
2071	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2072							$return . q{])}, "",
2073							q{addition},
2074							$tracelevel);
2075	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2076							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2077							Parse::RecDescent::_tracefirst($text),
2078							, q{addition},
2079							$tracelevel)
2080							}
2081	1772					3007	$_[1] = $text;
2082	1772					16558	return $return;
2083							}
2084
2085							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
2086							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::factor
2087							{
2088	6093			6093		8959	my $thisparser = $_[0];
2089	23			23		165	use vars q{$tracelevel};
	23					54
	23					16123
2090	6093		50			16083	local $tracelevel = ($tracelevel\|\|0)+1;
2091	6093					7106	$ERRORS = 0;
2092	6093					24334	my $thisrule = $thisparser->{"rules"}{"factor"};
2093
2094	6093	50				11664	Parse::RecDescent::_trace(q{Trying rule: [factor]},
2095							Parse::RecDescent::_tracefirst($_[1]),
2096							q{factor},
2097							$tracelevel)
2098							if defined $::RD_TRACE;
2099
2100
2101	6093					6710	my $err_at = @{$thisparser->{errors}};
	6093					11511
2102
2103	6093					7463	my $score;
2104							my $score_return;
2105	0					0	my $_tok;
2106	6093					7377	my $return = undef;
2107	6093					7189	my $_matched=0;
2108	6093					7218	my $commit=0;
2109	6093					9166	my @item = ();
2110	6093					9284	my %item = ();
2111	6093					8242	my $repeating = $_[2];
2112	6093					7139	my $_noactions = $_[3];
2113	6093	50				11132	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	6093					7258
	6093					11057
2114	6093					8352	my $_itempos = $_[5];
2115	6093	50				15494	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2116	6093					7851	my $text;
2117							my $lastsep;
2118	0					0	my $current_match;
2119	6093					20548	my $expectation = new Parse::RecDescent::Expectation(q{/(?:\\+\|-)*/});
2120	6093					48930	$expectation->at($_[1]);
2121
2122	6093					27297	my $thisline;
2123	6093					26812	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2124
2125
2126
2127	6093		33			58282	while (!$_matched && !$commit)
2128							{
2129
2130	6093	50				12354	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ number]},
2131							Parse::RecDescent::_tracefirst($_[1]),
2132							q{factor},
2133							$tracelevel)
2134							if defined $::RD_TRACE;
2135	6093					12776	my $thisprod = $thisrule->{"prods"}[0];
2136	6093					9416	$text = $_[1];
2137	6093					6774	my $_savetext;
2138	6093					11037	@item = (q{factor});
2139	6093					12036	%item = (__RULE__ => q{factor});
2140	6093					7589	my $repcount = 0;
2141
2142
2143	6093	50				11654	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2144							q{factor},
2145							$tracelevel)
2146							if defined $::RD_TRACE;
2147	6093					7847	undef $lastsep;
2148	6093					16872	$expectation->is(q{})->at($text);
2149
2150
2151	6093	50	33			65357	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	6093	50				58305
2152							{
2153	0	0				0	$text = $lastsep . $text if defined $lastsep;
2154	0					0	$expectation->failed();
2155	0	0				0	Parse::RecDescent::_trace(q{<>},
2156							Parse::RecDescent::_tracefirst($text))
2157							if defined $::RD_TRACE;
2158
2159	0					0	last;
2160							}
2161	6093					37827	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2162	6093					17708	substr($text,0,length($current_match),q{});
2163	6093	50				12706	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2164							. $current_match . q{])},
2165							Parse::RecDescent::_tracefirst($text))
2166							if defined $::RD_TRACE;
2167	6093					14539	push @item, $item{__PATTERN1__}=$current_match;
2168
2169
2170	6093	50				13286	Parse::RecDescent::_trace(q{Trying subrule: [number]},
2171							Parse::RecDescent::_tracefirst($text),
2172							q{factor},
2173							$tracelevel)
2174							if defined $::RD_TRACE;
2175	23			23		157	if (1) { no strict qw{refs};
	23					55
	23					20280
	6093					7013
2176	6093					16887	$expectation->is(q{number})->at($text);
2177	6093	100		6093		63950	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::number($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	6093					12421
2178							{
2179
2180	4307	50				9155	Parse::RecDescent::_trace(q{<>},
2181							Parse::RecDescent::_tracefirst($text),
2182							q{factor},
2183							$tracelevel)
2184							if defined $::RD_TRACE;
2185	4307					11403	$expectation->failed();
2186	4307					53621	last;
2187							}
2188	1786	50				7210	Parse::RecDescent::_trace(q{>>Matched subrule: [number]<< (return value: [}
2189							. $_tok . q{]},
2190
2191							Parse::RecDescent::_tracefirst($text),
2192							q{factor},
2193							$tracelevel)
2194							if defined $::RD_TRACE;
2195	1786					3635	$item{q{number}} = $_tok;
2196	1786					2938	push @item, $_tok;
2197
2198							}
2199
2200	1786	50				3867	Parse::RecDescent::_trace(q{Trying action},
2201							Parse::RecDescent::_tracefirst($text),
2202							q{factor},
2203							$tracelevel)
2204							if defined $::RD_TRACE;
2205
2206
2207	1786	50				3666	$_tok = ($_noactions) ? 0 : do {
2208							#warn 'unary_n '
2209							# if $Math::Symbolic::Parser::DEBUG;
2210	1786	100				3440	if ($item[1]) {
2211	146					561	my @it = split //, $item[1];
2212	146					402	my $ret = $item[2];
2213	146					284	foreach (grep {$_ eq '-'} @it) {
	146					602
2214	146					6465	$ret = Math::Symbolic::Operator->new('neg',$ret);
2215							}
2216							$ret
2217	146					374	}
2218							else {
2219	1640					3281	$item[2]
2220							}
2221							};
2222	1786	50				4550	unless (defined $_tok)
2223							{
2224	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2225							if defined $::RD_TRACE;
2226	0					0	last;
2227							}
2228	1786	50				3580	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2229							. $_tok . q{])},
2230							Parse::RecDescent::_tracefirst($text))
2231							if defined $::RD_TRACE;
2232	1786					2501	push @item, $_tok;
2233	1786					2717	$item{__ACTION1__}=$_tok;
2234
2235
2236	1786	50				3343	Parse::RecDescent::_trace(q{>>Matched production: [/(?:\\+\|-)*/ number]<<},
2237							Parse::RecDescent::_tracefirst($text),
2238							q{factor},
2239							$tracelevel)
2240							if defined $::RD_TRACE;
2241
2242
2243
2244	1786					2353	$_matched = 1;
2245	1786					3294	last;
2246							}
2247
2248
2249	6093		66			27844	while (!$_matched && !$commit)
2250							{
2251
2252	4307	50				8821	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ function]},
2253							Parse::RecDescent::_tracefirst($_[1]),
2254							q{factor},
2255							$tracelevel)
2256							if defined $::RD_TRACE;
2257	4307					8928	my $thisprod = $thisrule->{"prods"}[1];
2258	4307					7149	$text = $_[1];
2259	4307					4734	my $_savetext;
2260	4307					10793	@item = (q{factor});
2261	4307					10259	%item = (__RULE__ => q{factor});
2262	4307					5430	my $repcount = 0;
2263
2264
2265	4307	50				9481	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2266							q{factor},
2267							$tracelevel)
2268							if defined $::RD_TRACE;
2269	4307					5761	undef $lastsep;
2270	4307					11934	$expectation->is(q{})->at($text);
2271
2272
2273	4307	50	33			43193	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	4307	50				37961
2274							{
2275	0	0				0	$text = $lastsep . $text if defined $lastsep;
2276	0					0	$expectation->failed();
2277	0	0				0	Parse::RecDescent::_trace(q{<>},
2278							Parse::RecDescent::_tracefirst($text))
2279							if defined $::RD_TRACE;
2280
2281	0					0	last;
2282							}
2283	4307					20151	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2284	4307					12215	substr($text,0,length($current_match),q{});
2285	4307	50				9104	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2286							. $current_match . q{])},
2287							Parse::RecDescent::_tracefirst($text))
2288							if defined $::RD_TRACE;
2289	4307					13212	push @item, $item{__PATTERN1__}=$current_match;
2290
2291
2292	4307	50				13244	Parse::RecDescent::_trace(q{Trying subrule: [function]},
2293							Parse::RecDescent::_tracefirst($text),
2294							q{factor},
2295							$tracelevel)
2296							if defined $::RD_TRACE;
2297	23			23		151	if (1) { no strict qw{refs};
	23					91
	23					21368
	4307					5309
2298	4307					11603	$expectation->is(q{function})->at($text);
2299	4307	100		4307		49231	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	4307					8882
2300							{
2301
2302	3817	50				8457	Parse::RecDescent::_trace(q{<>},
2303							Parse::RecDescent::_tracefirst($text),
2304							q{factor},
2305							$tracelevel)
2306							if defined $::RD_TRACE;
2307	3817					10577	$expectation->failed();
2308	3817					28292	last;
2309							}
2310	490	50				2911	Parse::RecDescent::_trace(q{>>Matched subrule: [function]<< (return value: [}
2311							. $_tok . q{]},
2312
2313							Parse::RecDescent::_tracefirst($text),
2314							q{factor},
2315							$tracelevel)
2316							if defined $::RD_TRACE;
2317	490					1152	$item{q{function}} = $_tok;
2318	490					1106	push @item, $_tok;
2319
2320							}
2321
2322	490	50				1390	Parse::RecDescent::_trace(q{Trying action},
2323							Parse::RecDescent::_tracefirst($text),
2324							q{factor},
2325							$tracelevel)
2326							if defined $::RD_TRACE;
2327
2328
2329	490	50				1281	$_tok = ($_noactions) ? 0 : do {
2330							#warn 'unary_f '
2331							# if $Math::Symbolic::Parser::DEBUG;
2332	490	50				1126	if ($item[1]) {
2333	0					0	my @it = split //, $item[1];
2334	0					0	my $ret = $item[2];
2335	0					0	foreach (grep {$_ eq '-'} @it) {
	0					0
2336	0					0	$ret = Math::Symbolic::Operator->new('neg',$ret);
2337							}
2338							$ret
2339	0					0	}
2340							else {
2341	490					1410	$item[2]
2342							}
2343							};
2344	490	50				1257	unless (defined $_tok)
2345							{
2346	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2347							if defined $::RD_TRACE;
2348	0					0	last;
2349							}
2350	490	50				1499	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2351							. $_tok . q{])},
2352							Parse::RecDescent::_tracefirst($text))
2353							if defined $::RD_TRACE;
2354	490					827	push @item, $_tok;
2355	490					995	$item{__ACTION1__}=$_tok;
2356
2357
2358	490	50				1128	Parse::RecDescent::_trace(q{>>Matched production: [/(?:\\+\|-)*/ function]<<},
2359							Parse::RecDescent::_tracefirst($text),
2360							q{factor},
2361							$tracelevel)
2362							if defined $::RD_TRACE;
2363
2364
2365
2366	490					692	$_matched = 1;
2367	490					1057	last;
2368							}
2369
2370
2371	6093		66			24214	while (!$_matched && !$commit)
2372							{
2373
2374	3817	50				9559	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ variable]},
2375							Parse::RecDescent::_tracefirst($_[1]),
2376							q{factor},
2377							$tracelevel)
2378							if defined $::RD_TRACE;
2379	3817					8093	my $thisprod = $thisrule->{"prods"}[2];
2380	3817					6342	$text = $_[1];
2381	3817					4354	my $_savetext;
2382	3817					9139	@item = (q{factor});
2383	3817					9398	%item = (__RULE__ => q{factor});
2384	3817					4814	my $repcount = 0;
2385
2386
2387	3817	50				7472	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2388							q{factor},
2389							$tracelevel)
2390							if defined $::RD_TRACE;
2391	3817					5321	undef $lastsep;
2392	3817					10270	$expectation->is(q{})->at($text);
2393
2394
2395	3817	50	33			43938	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	3817	50				45897
2396							{
2397	0	0				0	$text = $lastsep . $text if defined $lastsep;
2398	0					0	$expectation->failed();
2399	0	0				0	Parse::RecDescent::_trace(q{<>},
2400							Parse::RecDescent::_tracefirst($text))
2401							if defined $::RD_TRACE;
2402
2403	0					0	last;
2404							}
2405	3817					20764	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2406	3817					11534	substr($text,0,length($current_match),q{});
2407	3817	50				8272	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2408							. $current_match . q{])},
2409							Parse::RecDescent::_tracefirst($text))
2410							if defined $::RD_TRACE;
2411	3817					10361	push @item, $item{__PATTERN1__}=$current_match;
2412
2413
2414	3817	50				8034	Parse::RecDescent::_trace(q{Trying subrule: [variable]},
2415							Parse::RecDescent::_tracefirst($text),
2416							q{factor},
2417							$tracelevel)
2418							if defined $::RD_TRACE;
2419	23			23		166	if (1) { no strict qw{refs};
	23					58
	23					27192
	3817					4329
2420	3817					10919	$expectation->is(q{variable})->at($text);
2421	3817	100		3817		39989	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::variable($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	3817					8076
2422							{
2423
2424	625	50				1486	Parse::RecDescent::_trace(q{<>},
2425							Parse::RecDescent::_tracefirst($text),
2426							q{factor},
2427							$tracelevel)
2428							if defined $::RD_TRACE;
2429	625					1778	$expectation->failed();
2430	625					4551	last;
2431							}
2432	3192	50				12941	Parse::RecDescent::_trace(q{>>Matched subrule: [variable]<< (return value: [}
2433							. $_tok . q{]},
2434
2435							Parse::RecDescent::_tracefirst($text),
2436							q{factor},
2437							$tracelevel)
2438							if defined $::RD_TRACE;
2439	3192					6070	$item{q{variable}} = $_tok;
2440	3192					5337	push @item, $_tok;
2441
2442							}
2443
2444	3192	50				6473	Parse::RecDescent::_trace(q{Trying action},
2445							Parse::RecDescent::_tracefirst($text),
2446							q{factor},
2447							$tracelevel)
2448							if defined $::RD_TRACE;
2449
2450
2451	3192	50				5399	$_tok = ($_noactions) ? 0 : do {
2452							#warn 'unary_v '
2453							# if $Math::Symbolic::Parser::DEBUG;
2454	3192	100				6673	if ($item[1]) {
2455	22					111	my @it = split //, $item[1];
2456	22					49	my $ret = $item[2];
2457	22					55	foreach (grep {$_ eq '-'} @it) {
	22					97
2458	22					132	$ret = Math::Symbolic::Operator->new('neg',$ret);
2459							}
2460							$ret
2461	22					57	}
2462							else {
2463	3170					5578	$item[2]
2464							}
2465							};
2466	3192	50				7210	unless (defined $_tok)
2467							{
2468	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2469							if defined $::RD_TRACE;
2470	0					0	last;
2471							}
2472	3192	50				6628	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2473							. $_tok . q{])},
2474							Parse::RecDescent::_tracefirst($text))
2475							if defined $::RD_TRACE;
2476	3192					4512	push @item, $_tok;
2477	3192					4874	$item{__ACTION1__}=$_tok;
2478
2479
2480	3192	50				9137	Parse::RecDescent::_trace(q{>>Matched production: [/(?:\\+\|-)*/ variable]<<},
2481							Parse::RecDescent::_tracefirst($text),
2482							q{factor},
2483							$tracelevel)
2484							if defined $::RD_TRACE;
2485
2486
2487
2488	3192					4078	$_matched = 1;
2489	3192					5805	last;
2490							}
2491
2492
2493	6093		66			18403	while (!$_matched && !$commit)
2494							{
2495
2496	625	50				1420	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ '(' expr ')']},
2497							Parse::RecDescent::_tracefirst($_[1]),
2498							q{factor},
2499							$tracelevel)
2500							if defined $::RD_TRACE;
2501	625					1616	my $thisprod = $thisrule->{"prods"}[3];
2502	625					1313	$text = $_[1];
2503	625					877	my $_savetext;
2504	625					1767	@item = (q{factor});
2505	625					1920	%item = (__RULE__ => q{factor});
2506	625					857	my $repcount = 0;
2507
2508
2509	625	50				1617	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2510							q{factor},
2511							$tracelevel)
2512							if defined $::RD_TRACE;
2513	625					5404	undef $lastsep;
2514	625					1961	$expectation->is(q{})->at($text);
2515
2516
2517	625	50	33			7008	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	625	50				6530
2518							{
2519	0	0				0	$text = $lastsep . $text if defined $lastsep;
2520	0					0	$expectation->failed();
2521	0	0				0	Parse::RecDescent::_trace(q{<>},
2522							Parse::RecDescent::_tracefirst($text))
2523							if defined $::RD_TRACE;
2524
2525	0					0	last;
2526							}
2527	625					3598	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2528	625					2195	substr($text,0,length($current_match),q{});
2529	625	50				1599	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2530							. $current_match . q{])},
2531							Parse::RecDescent::_tracefirst($text))
2532							if defined $::RD_TRACE;
2533	625					1681	push @item, $item{__PATTERN1__}=$current_match;
2534
2535
2536	625	50				1426	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
2537							Parse::RecDescent::_tracefirst($text),
2538							q{factor},
2539							$tracelevel)
2540							if defined $::RD_TRACE;
2541	625					814	undef $lastsep;
2542	625					2123	$expectation->is(q{'('})->at($text);
2543
2544
2545	625	50	33			6629	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	625	50				6147
2546							{
2547	0	0				0	$text = $lastsep . $text if defined $lastsep;
2548
2549	0					0	$expectation->failed();
2550	0	0				0	Parse::RecDescent::_trace(qq{<>},
2551							Parse::RecDescent::_tracefirst($text))
2552							if defined $::RD_TRACE;
2553	0					0	last;
2554							}
2555	625					3151	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2556	625					1902	substr($text,0,length($current_match),q{});
2557	625	50				9996	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2558							. $current_match . q{])},
2559							Parse::RecDescent::_tracefirst($text))
2560							if defined $::RD_TRACE;
2561	625					1783	push @item, $item{__STRING1__}=$current_match;
2562
2563
2564	625	50				1596	Parse::RecDescent::_trace(q{Trying subrule: [expr]},
2565							Parse::RecDescent::_tracefirst($text),
2566							q{factor},
2567							$tracelevel)
2568							if defined $::RD_TRACE;
2569	23			23		151	if (1) { no strict qw{refs};
	23					73
	23					31496
	625					745
2570	625					1913	$expectation->is(q{expr})->at($text);
2571	625	50		625		8097	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	625					1455
2572							{
2573
2574	0	0				0	Parse::RecDescent::_trace(q{<>},
2575							Parse::RecDescent::_tracefirst($text),
2576							q{factor},
2577							$tracelevel)
2578							if defined $::RD_TRACE;
2579	0					0	$expectation->failed();
2580	0					0	last;
2581							}
2582	625	50				6748	Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
2583							. $_tok . q{]},
2584
2585							Parse::RecDescent::_tracefirst($text),
2586							q{factor},
2587							$tracelevel)
2588							if defined $::RD_TRACE;
2589	625					1475	$item{q{expr}} = $_tok;
2590	625					1331	push @item, $_tok;
2591
2592							}
2593
2594	625	50				1294	Parse::RecDescent::_trace(q{Trying terminal: [')']},
2595							Parse::RecDescent::_tracefirst($text),
2596							q{factor},
2597							$tracelevel)
2598							if defined $::RD_TRACE;
2599	625					1278	undef $lastsep;
2600	625					2178	$expectation->is(q{')'})->at($text);
2601
2602
2603	625	50	33			8057	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	625	50				7243
2604							{
2605	0	0				0	$text = $lastsep . $text if defined $lastsep;
2606
2607	0					0	$expectation->failed();
2608	0	0				0	Parse::RecDescent::_trace(qq{<>},
2609							Parse::RecDescent::_tracefirst($text))
2610							if defined $::RD_TRACE;
2611	0					0	last;
2612							}
2613	625					3795	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2614	625					5169	substr($text,0,length($current_match),q{});
2615	625	50				1952	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2616							. $current_match . q{])},
2617							Parse::RecDescent::_tracefirst($text))
2618							if defined $::RD_TRACE;
2619	625					2132	push @item, $item{__STRING2__}=$current_match;
2620
2621
2622	625	50				1844	Parse::RecDescent::_trace(q{Trying action},
2623							Parse::RecDescent::_tracefirst($text),
2624							q{factor},
2625							$tracelevel)
2626							if defined $::RD_TRACE;
2627
2628
2629	625	50				1575	$_tok = ($_noactions) ? 0 : do {
2630							#warn 'unary_expr '
2631							# if $Math::Symbolic::Parser::DEBUG;
2632	625	100				1379	if ($item[1]) {
2633	4					18	my @it = split //, $item[1];
2634	4					7	my $ret = $item[3];
2635	4					9	foreach (grep {$_ eq '-'} @it) {
	10					23
2636	10					31	$ret = Math::Symbolic::Operator->new('neg',$ret);
2637							}
2638							$ret
2639	4					10	}
2640							else {
2641	621					1843	$item[3]
2642							}
2643							};
2644	625	50				1658	unless (defined $_tok)
2645							{
2646	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2647							if defined $::RD_TRACE;
2648	0					0	last;
2649							}
2650	625	50				1471	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2651							. $_tok . q{])},
2652							Parse::RecDescent::_tracefirst($text))
2653							if defined $::RD_TRACE;
2654	625					1111	push @item, $_tok;
2655	625					1310	$item{__ACTION1__}=$_tok;
2656
2657
2658	625	50				1332	Parse::RecDescent::_trace(q{>>Matched production: [/(?:\\+\|-)*/ '(' expr ')']<<},
2659							Parse::RecDescent::_tracefirst($text),
2660							q{factor},
2661							$tracelevel)
2662							if defined $::RD_TRACE;
2663
2664
2665
2666	625					1045	$_matched = 1;
2667	625					1993	last;
2668							}
2669
2670
2671	6093	50	33			14360	unless ( $_matched \|\| defined($score) )
2672							{
2673
2674
2675	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
2676	0	0				0	Parse::RecDescent::_trace(q{<>},
2677							Parse::RecDescent::_tracefirst($_[1]),
2678							q{factor},
2679							$tracelevel)
2680							if defined $::RD_TRACE;
2681	0					0	return undef;
2682							}
2683	6093	50	33			26867	if (!defined($return) && defined($score))
2684							{
2685	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2686							q{factor},
2687							$tracelevel)
2688							if defined $::RD_TRACE;
2689	0					0	$return = $score_return;
2690							}
2691	6093					7480	splice @{$thisparser->{errors}}, $err_at;
	6093					12454
2692	6093	50				19523	$return = $item[$#item] unless defined $return;
2693	6093	50				12849	if (defined $::RD_TRACE)
2694							{
2695	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2696							$return . q{])}, "",
2697							q{factor},
2698							$tracelevel);
2699	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2700							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2701							Parse::RecDescent::_tracefirst($text),
2702							, q{factor},
2703							$tracelevel)
2704							}
2705	6093					10436	$_[1] = $text;
2706	6093					57803	return $return;
2707							}
2708
2709							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
2710							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::identifier_list
2711							{
2712	159			159		290	my $thisparser = $_[0];
2713	23			23		190	use vars q{$tracelevel};
	23					73
	23					78592
2714	159		50			447	local $tracelevel = ($tracelevel\|\|0)+1;
2715	159					208	$ERRORS = 0;
2716	159					369	my $thisrule = $thisparser->{"rules"}{"identifier_list"};
2717
2718	159	50				393	Parse::RecDescent::_trace(q{Trying rule: [identifier_list]},
2719							Parse::RecDescent::_tracefirst($_[1]),
2720							q{identifier_list},
2721							$tracelevel)
2722							if defined $::RD_TRACE;
2723
2724
2725	159					199	my $err_at = @{$thisparser->{errors}};
	159					464
2726
2727	159					270	my $score;
2728							my $score_return;
2729	0					0	my $_tok;
2730	159					211	my $return = undef;
2731	159					188	my $_matched=0;
2732	159					193	my $commit=0;
2733	159					320	my @item = ();
2734	159					263	my %item = ();
2735	159					210	my $repeating = $_[2];
2736	159					190	my $_noactions = $_[3];
2737	159	50				347	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	159					169
	159					554
2738	159					413	my $_itempos = $_[5];
2739	159	50				442	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2740	159					239	my $text;
2741							my $lastsep;
2742	0					0	my $current_match;
2743	159					783	my $expectation = new Parse::RecDescent::Expectation(q{});
2744	159					1603	$expectation->at($_[1]);
2745
2746	159					837	my $thisline;
2747	159					809	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2748
2749
2750
2751	159		33			2348	while (!$_matched && !$commit)
2752							{
2753
2754	159	50				359	Parse::RecDescent::_trace(q{Trying production: []},
2755							Parse::RecDescent::_tracefirst($_[1]),
2756							q{identifier_list},
2757							$tracelevel)
2758							if defined $::RD_TRACE;
2759	159					578	my $thisprod = $thisrule->{"prods"}[0];
2760	159					254	$text = $_[1];
2761	159					186	my $_savetext;
2762	159					315	@item = (q{identifier_list});
2763	159					565	%item = (__RULE__ => q{identifier_list});
2764	159					225	my $repcount = 0;
2765
2766
2767	159	50				347	Parse::RecDescent::_trace(q{Trying operator: []},
2768							Parse::RecDescent::_tracefirst($text),
2769							q{identifier_list},
2770							$tracelevel)
2771							if defined $::RD_TRACE;
2772	159					458	$expectation->is(q{})->at($text);
2773
2774	159					1324	$_tok = undef;
2775	159					195	OPLOOP: while (1)
2776							{
2777	159					254	$repcount = 0;
2778	159					200	my @item;
2779							my %item;
2780
2781							# MATCH LEFTARG
2782
2783	159	50				8813	Parse::RecDescent::_trace(q{Trying terminal: [/[a-zA-Z][a-zA-Z0-9_]*/]}, Parse::RecDescent::_tracefirst($text),
2784							q{identifier_list},
2785							$tracelevel)
2786							if defined $::RD_TRACE;
2787	159					190	undef $lastsep;
2788	159					385	$expectation->is(q{/[a-zA-Z][a-zA-Z0-9_]*/})->at($text);
2789
2790
2791	159	50	33			1952	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	159	50				1649
2792							{
2793	0	0				0	$text = $lastsep . $text if defined $lastsep;
2794	0					0	$expectation->failed();
2795	0	0				0	Parse::RecDescent::_trace(q{<>},
2796							Parse::RecDescent::_tracefirst($text))
2797							if defined $::RD_TRACE;
2798
2799	0					0	last;
2800							}
2801	159					801	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2802	159					437	substr($text,0,length($current_match),q{});
2803	159	50				359	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2804							. $current_match . q{])},
2805							Parse::RecDescent::_tracefirst($text))
2806							if defined $::RD_TRACE;
2807	159					415	push @item, $item{__PATTERN1__}=$current_match;
2808
2809
2810
2811
2812	159					213	$repcount++;
2813
2814	159					263	my $savetext = $text;
2815	159					199	my $backtrack;
2816
2817							# MATCH (OP RIGHTARG)(s)
2818	159					356	while ($repcount < 100000000)
2819							{
2820	233					482	$backtrack = 0;
2821
2822	233	50				432	Parse::RecDescent::_trace(q{Trying terminal: [',']},
2823							Parse::RecDescent::_tracefirst($text),
2824							q{identifier_list},
2825							$tracelevel)
2826							if defined $::RD_TRACE;
2827	233					533	undef $lastsep;
2828	233					856	$expectation->is(q{','})->at($text);
2829
2830
2831	233	50	66			2548	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\,/)
	233	100				2079
2832							{
2833	159	50				462	$text = $lastsep . $text if defined $lastsep;
2834
2835	159					444	$expectation->failed();
2836	159	50				1429	Parse::RecDescent::_trace(qq{<>},
2837							Parse::RecDescent::_tracefirst($text))
2838							if defined $::RD_TRACE;
2839	159					282	last;
2840							}
2841	74					1178	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2842	74					171	substr($text,0,length($current_match),q{});
2843	74	50				141	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2844							. $current_match . q{])},
2845							Parse::RecDescent::_tracefirst($text))
2846							if defined $::RD_TRACE;
2847	74					143	push @item, $item{__STRING1__}=$current_match;
2848
2849
2850	74					85	pop @item;
2851
2852
2853	74	50				311	Parse::RecDescent::_trace(q{Trying terminal: [/[a-zA-Z][a-zA-Z0-9_]*/]}, Parse::RecDescent::_tracefirst($text),
2854							q{identifier_list},
2855							$tracelevel)
2856							if defined $::RD_TRACE;
2857	74					108	undef $lastsep;
2858	74					392	$expectation->is(q{/[a-zA-Z][a-zA-Z0-9_]*/})->at($text);
2859
2860
2861	74	50	33			1002	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	74	50				2798
2862							{
2863	0	0				0	$text = $lastsep . $text if defined $lastsep;
2864	0					0	$expectation->failed();
2865	0	0				0	Parse::RecDescent::_trace(q{<>},
2866							Parse::RecDescent::_tracefirst($text))
2867							if defined $::RD_TRACE;
2868
2869	0					0	last;
2870							}
2871	74					667	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2872	74					166	substr($text,0,length($current_match),q{});
2873	74	50				312	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2874							. $current_match . q{])},
2875							Parse::RecDescent::_tracefirst($text))
2876							if defined $::RD_TRACE;
2877	74					307	push @item, $item{__PATTERN2__}=$current_match;
2878
2879
2880	74					85	$savetext = $text;
2881	74					184	$repcount++;
2882							}
2883	159					261	$text = $savetext;
2884	159	50				318	pop @item if $backtrack;
2885
2886	159	50				374	unless (@item) { undef $_tok; last }
	0					0
	0					0
2887	159					392	$_tok = [ @item ];
2888
2889	159					473	last;
2890							} # end of OPLOOP
2891
2892	159	50				358	unless ($repcount>=1)
2893							{
2894	0	0				0	Parse::RecDescent::_trace(q{<]>>},
2895							Parse::RecDescent::_tracefirst($text),
2896							q{identifier_list},
2897							$tracelevel)
2898							if defined $::RD_TRACE;
2899	0					0	$expectation->failed();
2900	0					0	last;
2901							}
2902	159	50				362	Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [}
2903	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
2904							Parse::RecDescent::_tracefirst($text),
2905							q{identifier_list},
2906							$tracelevel)
2907							if defined $::RD_TRACE;
2908
2909	159		50			529	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
2910
2911	159	50				296	Parse::RecDescent::_trace(q{Trying action},
2912							Parse::RecDescent::_tracefirst($text),
2913							q{identifier_list},
2914							$tracelevel)
2915							if defined $::RD_TRACE;
2916
2917
2918	159	50				302	$_tok = ($_noactions) ? 0 : do {
2919							#warn 'identifier_list '
2920							# if $Math::Symbolic::Parser::DEBUG;
2921	159					244	$item[1]
2922							};
2923	159	50				367	unless (defined $_tok)
2924							{
2925	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2926							if defined $::RD_TRACE;
2927	0					0	last;
2928							}
2929	159	50				305	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2930							. $_tok . q{])},
2931							Parse::RecDescent::_tracefirst($text))
2932							if defined $::RD_TRACE;
2933	159					229	push @item, $_tok;
2934	159					300	$item{__ACTION1__}=$_tok;
2935
2936
2937	159	50				293	Parse::RecDescent::_trace(q{>>Matched production: []<<},
2938							Parse::RecDescent::_tracefirst($text),
2939							q{identifier_list},
2940							$tracelevel)
2941							if defined $::RD_TRACE;
2942
2943
2944
2945	159					177	$_matched = 1;
2946	159					380	last;
2947							}
2948
2949
2950	159	50	33			7723	unless ( $_matched \|\| defined($score) )
2951							{
2952
2953
2954	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
2955	0	0				0	Parse::RecDescent::_trace(q{<>},
2956							Parse::RecDescent::_tracefirst($_[1]),
2957							q{identifier_list},
2958							$tracelevel)
2959							if defined $::RD_TRACE;
2960	0					0	return undef;
2961							}
2962	159	50	33			713	if (!defined($return) && defined($score))
2963							{
2964	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2965							q{identifier_list},
2966							$tracelevel)
2967							if defined $::RD_TRACE;
2968	0					0	$return = $score_return;
2969							}
2970	159					198	splice @{$thisparser->{errors}}, $err_at;
	159					367
2971	159	50				438	$return = $item[$#item] unless defined $return;
2972	159	50				358	if (defined $::RD_TRACE)
2973							{
2974	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2975							$return . q{])}, "",
2976							q{identifier_list},
2977							$tracelevel);
2978	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2979							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2980							Parse::RecDescent::_tracefirst($text),
2981							, q{identifier_list},
2982							$tracelevel)
2983							}
2984	159					281	$_[1] = $text;
2985	159					1248	return $return;
2986							}
2987
2988							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
2989							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr
2990							{
2991	1772			1772		3604	my $thisparser = $_[0];
2992	23			23		277	use vars q{$tracelevel};
	23					66
	23					10796
2993	1772		50			6018	local $tracelevel = ($tracelevel\|\|0)+1;
2994	1772					2442	$ERRORS = 0;
2995	1772					4299	my $thisrule = $thisparser->{"rules"}{"expr"};
2996
2997	1772	50				4291	Parse::RecDescent::_trace(q{Trying rule: [expr]},
2998							Parse::RecDescent::_tracefirst($_[1]),
2999							q{expr},
3000							$tracelevel)
3001							if defined $::RD_TRACE;
3002
3003
3004	1772					2283	my $err_at = @{$thisparser->{errors}};
	1772					4077
3005
3006	1772					2918	my $score;
3007							my $score_return;
3008	0					0	my $_tok;
3009	1772					2524	my $return = undef;
3010	1772					2363	my $_matched=0;
3011	1772					2281	my $commit=0;
3012	1772					3921	my @item = ();
3013	1772					3138	my %item = ();
3014	1772					2914	my $repeating = $_[2];
3015	1772					2658	my $_noactions = $_[3];
3016	1772	50				4475	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	1772					2391
	1772					5069
3017	1772					3202	my $_itempos = $_[5];
3018	1772	50				5361	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3019	1772					2956	my $text;
3020							my $lastsep;
3021	0					0	my $current_match;
3022	1772					6592	my $expectation = new Parse::RecDescent::Expectation(q{addition});
3023	1772					25281	$expectation->at($_[1]);
3024
3025	1772					7606	my $thisline;
3026	1772					7954	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3027
3028
3029
3030	1772		33			42379	while (!$_matched && !$commit)
3031							{
3032
3033	1772	50				4787	Parse::RecDescent::_trace(q{Trying production: [addition]},
3034							Parse::RecDescent::_tracefirst($_[1]),
3035							q{expr},
3036							$tracelevel)
3037							if defined $::RD_TRACE;
3038	1772					5034	my $thisprod = $thisrule->{"prods"}[0];
3039	1772					2766	$text = $_[1];
3040	1772					2549	my $_savetext;
3041	1772					3874	@item = (q{expr});
3042	1772					4052	%item = (__RULE__ => q{expr});
3043	1772					2423	my $repcount = 0;
3044
3045
3046	1772	50				6864	Parse::RecDescent::_trace(q{Trying subrule: [addition]},
3047							Parse::RecDescent::_tracefirst($text),
3048							q{expr},
3049							$tracelevel)
3050							if defined $::RD_TRACE;
3051	23			23		191	if (1) { no strict qw{refs};
	23					51
	23					16709
	1772					3504
3052	1772					5756	$expectation->is(q{})->at($text);
3053	1772	50		1772		20744	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::addition($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	1772					3783
3054							{
3055
3056	0	0				0	Parse::RecDescent::_trace(q{<>},
3057							Parse::RecDescent::_tracefirst($text),
3058							q{expr},
3059							$tracelevel)
3060							if defined $::RD_TRACE;
3061	0					0	$expectation->failed();
3062	0					0	last;
3063							}
3064	1772	50				8451	Parse::RecDescent::_trace(q{>>Matched subrule: [addition]<< (return value: [}
3065							. $_tok . q{]},
3066
3067							Parse::RecDescent::_tracefirst($text),
3068							q{expr},
3069							$tracelevel)
3070							if defined $::RD_TRACE;
3071	1772					23474	$item{q{addition}} = $_tok;
3072	1772					3648	push @item, $_tok;
3073
3074							}
3075
3076	1772	50				3777	Parse::RecDescent::_trace(q{Trying action},
3077							Parse::RecDescent::_tracefirst($text),
3078							q{expr},
3079							$tracelevel)
3080							if defined $::RD_TRACE;
3081
3082
3083	1772	50				3702	$_tok = ($_noactions) ? 0 : do {
3084							#warn 'expr ' if $Math::Symbolic::Parser::DEBUG;
3085	1772					2640	$item[1]
3086							};
3087	1772	50				4082	unless (defined $_tok)
3088							{
3089	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
3090							if defined $::RD_TRACE;
3091	0					0	last;
3092							}
3093	1772	50				3889	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3094							. $_tok . q{])},
3095							Parse::RecDescent::_tracefirst($text))
3096							if defined $::RD_TRACE;
3097	1772					2357	push @item, $_tok;
3098	1772					2838	$item{__ACTION1__}=$_tok;
3099
3100
3101	1772	50				3675	Parse::RecDescent::_trace(q{>>Matched production: [addition]<<},
3102							Parse::RecDescent::_tracefirst($text),
3103							q{expr},
3104							$tracelevel)
3105							if defined $::RD_TRACE;
3106
3107
3108
3109	1772					2095	$_matched = 1;
3110	1772					3106	last;
3111							}
3112
3113
3114	1772	50	33			5410	unless ( $_matched \|\| defined($score) )
3115							{
3116
3117
3118	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
3119	0	0				0	Parse::RecDescent::_trace(q{<>},
3120							Parse::RecDescent::_tracefirst($_[1]),
3121							q{expr},
3122							$tracelevel)
3123							if defined $::RD_TRACE;
3124	0					0	return undef;
3125							}
3126	1772	50	33			8251	if (!defined($return) && defined($score))
3127							{
3128	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3129							q{expr},
3130							$tracelevel)
3131							if defined $::RD_TRACE;
3132	0					0	$return = $score_return;
3133							}
3134	1772					2214	splice @{$thisparser->{errors}}, $err_at;
	1772					4023
3135	1772	50				4721	$return = $item[$#item] unless defined $return;
3136	1772	50				3909	if (defined $::RD_TRACE)
3137							{
3138	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3139							$return . q{])}, "",
3140							q{expr},
3141							$tracelevel);
3142	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3143							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3144							Parse::RecDescent::_tracefirst($text),
3145							, q{expr},
3146							$tracelevel)
3147							}
3148	1772					3394	$_[1] = $text;
3149	1772					17617	return $return;
3150							}
3151
3152							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
3153							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::mult_op
3154							{
3155	2907			2907		5360	my $thisparser = $_[0];
3156	23			23		166	use vars q{$tracelevel};
	23					52
	23					40795
3157	2907		50			8358	local $tracelevel = ($tracelevel\|\|0)+1;
3158	2907					3822	$ERRORS = 0;
3159	2907					6465	my $thisrule = $thisparser->{"rules"}{"mult_op"};
3160
3161	2907	50				6684	Parse::RecDescent::_trace(q{Trying rule: [mult_op]},
3162							Parse::RecDescent::_tracefirst($_[1]),
3163							q{mult_op},
3164							$tracelevel)
3165							if defined $::RD_TRACE;
3166
3167
3168	2907					3933	my $err_at = @{$thisparser->{errors}};
	2907					5805
3169
3170	2907					3872	my $score;
3171							my $score_return;
3172	0					0	my $_tok;
3173	2907					4171	my $return = undef;
3174	2907					3621	my $_matched=0;
3175	2907					4019	my $commit=0;
3176	2907					4917	my @item = ();
3177	2907					5071	my %item = ();
3178	2907					3638	my $repeating = $_[2];
3179	2907					3645	my $_noactions = $_[3];
3180	2907	50				6475	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2907					7438
	2907					5550
3181	2907					4318	my $_itempos = $_[5];
3182	2907	50				9427	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3183	2907					3798	my $text;
3184							my $lastsep;
3185	0					0	my $current_match;
3186	2907					10363	my $expectation = new Parse::RecDescent::Expectation(q{'*', or '/'});
3187	2907					23839	$expectation->at($_[1]);
3188
3189	2907					12390	my $thisline;
3190	2907					13819	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3191
3192
3193
3194	2907		33			28223	while (!$_matched && !$commit)
3195							{
3196
3197	2907	50				6971	Parse::RecDescent::_trace(q{Trying production: ['*']},
3198							Parse::RecDescent::_tracefirst($_[1]),
3199							q{mult_op},
3200							$tracelevel)
3201							if defined $::RD_TRACE;
3202	2907					7501	my $thisprod = $thisrule->{"prods"}[0];
3203	2907					4382	$text = $_[1];
3204	2907					3284	my $_savetext;
3205	2907					5938	@item = (q{mult_op});
3206	2907					6592	%item = (__RULE__ => q{mult_op});
3207	2907					4418	my $repcount = 0;
3208
3209
3210	2907	50				6031	Parse::RecDescent::_trace(q{Trying terminal: ['*']},
3211							Parse::RecDescent::_tracefirst($text),
3212							q{mult_op},
3213							$tracelevel)
3214							if defined $::RD_TRACE;
3215	2907					4752	undef $lastsep;
3216	2907					8565	$expectation->is(q{})->at($text);
3217
3218
3219	2907	50	66			32561	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\*/)
	2907	100				26134
3220							{
3221	2347	50				7118	$text = $lastsep . $text if defined $lastsep;
3222
3223	2347					7225	$expectation->failed();
3224	2347	50				10972	Parse::RecDescent::_trace(qq{<>},
3225							Parse::RecDescent::_tracefirst($text))
3226							if defined $::RD_TRACE;
3227	2347					5411	last;
3228							}
3229	560					3388	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3230	560					2058	substr($text,0,length($current_match),q{});
3231	560	50				1834	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3232							. $current_match . q{])},
3233							Parse::RecDescent::_tracefirst($text))
3234							if defined $::RD_TRACE;
3235	560					1767	push @item, $item{__STRING1__}=$current_match;
3236
3237
3238	560	50				1984	Parse::RecDescent::_trace(q{>>Matched production: ['*']<<},
3239							Parse::RecDescent::_tracefirst($text),
3240							q{mult_op},
3241							$tracelevel)
3242							if defined $::RD_TRACE;
3243
3244
3245
3246	560					885	$_matched = 1;
3247	560					1250	last;
3248							}
3249
3250
3251	2907		66			11578	while (!$_matched && !$commit)
3252							{
3253
3254	2347	50				5343	Parse::RecDescent::_trace(q{Trying production: ['/']},
3255							Parse::RecDescent::_tracefirst($_[1]),
3256							q{mult_op},
3257							$tracelevel)
3258							if defined $::RD_TRACE;
3259	2347					4785	my $thisprod = $thisrule->{"prods"}[1];
3260	2347					3642	$text = $_[1];
3261	2347					2938	my $_savetext;
3262	2347					4658	@item = (q{mult_op});
3263	2347					5190	%item = (__RULE__ => q{mult_op});
3264	2347					3275	my $repcount = 0;
3265
3266
3267	2347	50				4925	Parse::RecDescent::_trace(q{Trying terminal: ['/']},
3268							Parse::RecDescent::_tracefirst($text),
3269							q{mult_op},
3270							$tracelevel)
3271							if defined $::RD_TRACE;
3272	2347					3088	undef $lastsep;
3273	2347					7325	$expectation->is(q{})->at($text);
3274
3275
3276	2347	50	66			30296	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\//)
	2347	100				19234
3277							{
3278	2262	50				7193	$text = $lastsep . $text if defined $lastsep;
3279
3280	2262					7192	$expectation->failed();
3281	2262	50				10725	Parse::RecDescent::_trace(qq{<>},
3282							Parse::RecDescent::_tracefirst($text))
3283							if defined $::RD_TRACE;
3284	2262					4637	last;
3285							}
3286	85					669	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3287	85					292	substr($text,0,length($current_match),q{});
3288	85	50				273	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3289							. $current_match . q{])},
3290							Parse::RecDescent::_tracefirst($text))
3291							if defined $::RD_TRACE;
3292	85					281	push @item, $item{__STRING1__}=$current_match;
3293
3294
3295	85	50				243	Parse::RecDescent::_trace(q{>>Matched production: ['/']<<},
3296							Parse::RecDescent::_tracefirst($text),
3297							q{mult_op},
3298							$tracelevel)
3299							if defined $::RD_TRACE;
3300
3301
3302
3303	85					137	$_matched = 1;
3304	85					203	last;
3305							}
3306
3307
3308	2907	100	66			13255	unless ( $_matched \|\| defined($score) )
3309							{
3310
3311
3312	2262					3594	$_[1] = $text; # NOT SURE THIS IS NEEDED
3313	2262	50				4850	Parse::RecDescent::_trace(q{<>},
3314							Parse::RecDescent::_tracefirst($_[1]),
3315							q{mult_op},
3316							$tracelevel)
3317							if defined $::RD_TRACE;
3318	2262					16402	return undef;
3319							}
3320	645	50	33			3404	if (!defined($return) && defined($score))
3321							{
3322	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3323							q{mult_op},
3324							$tracelevel)
3325							if defined $::RD_TRACE;
3326	0					0	$return = $score_return;
3327							}
3328	645					1034	splice @{$thisparser->{errors}}, $err_at;
	645					1749
3329	645	50				2155	$return = $item[$#item] unless defined $return;
3330	645	50				1678	if (defined $::RD_TRACE)
3331							{
3332	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3333							$return . q{])}, "",
3334							q{mult_op},
3335							$tracelevel);
3336	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3337							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3338							Parse::RecDescent::_tracefirst($text),
3339							, q{mult_op},
3340							$tracelevel)
3341							}
3342	645					1149	$_[1] = $text;
3343	645					5768	return $return;
3344							}
3345
3346							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
3347							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function_name
3348							{
3349	4307			4307		7637	my $thisparser = $_[0];
3350	23			23		176	use vars q{$tracelevel};
	23					56
	23					257803
3351	4307		50			11434	local $tracelevel = ($tracelevel\|\|0)+1;
3352	4307					6449	$ERRORS = 0;
3353	4307					9087	my $thisrule = $thisparser->{"rules"}{"function_name"};
3354
3355	4307	50				8905	Parse::RecDescent::_trace(q{Trying rule: [function_name]},
3356							Parse::RecDescent::_tracefirst($_[1]),
3357							q{function_name},
3358							$tracelevel)
3359							if defined $::RD_TRACE;
3360
3361
3362	4307					4822	my $err_at = @{$thisparser->{errors}};
	4307					11100
3363
3364	4307					6116	my $score;
3365							my $score_return;
3366	0					0	my $_tok;
3367	4307					8496	my $return = undef;
3368	4307					4832	my $_matched=0;
3369	4307					5061	my $commit=0;
3370	4307					11188	my @item = ();
3371	4307					6531	my %item = ();
3372	4307					5384	my $repeating = $_[2];
3373	4307					5476	my $_noactions = $_[3];
3374	4307	50				9177	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	4307					5013
	4307					7870
3375	4307					6371	my $_itempos = $_[5];
3376	4307	50				11011	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3377	4307					6513	my $text;
3378							my $lastsep;
3379	0					0	my $current_match;
3380	4307					14689	my $expectation = new Parse::RecDescent::Expectation(q{'log', or 'partial_derivative', or 'total_derivative', or 'sinh', or 'cosh', or 'asinh', or 'acosh', or 'asin', or 'acos', or 'atan2', or 'atan', or 'acot', or 'sin', or 'cos', or 'tan', or 'cot', or 'exp', or 'sqrt'});
3381	4307					36535	$expectation->at($_[1]);
3382
3383	4307					17144	my $thisline;
3384	4307					17801	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3385
3386
3387
3388	4307		33			41190	while (!$_matched && !$commit)
3389							{
3390
3391	4307	50				8786	Parse::RecDescent::_trace(q{Trying production: ['log']},
3392							Parse::RecDescent::_tracefirst($_[1]),
3393							q{function_name},
3394							$tracelevel)
3395							if defined $::RD_TRACE;
3396	4307					9770	my $thisprod = $thisrule->{"prods"}[0];
3397	4307					5543	$text = $_[1];
3398	4307					5078	my $_savetext;
3399	4307					8310	@item = (q{function_name});
3400	4307					9071	%item = (__RULE__ => q{function_name});
3401	4307					11788	my $repcount = 0;
3402
3403
3404	4307	50				8200	Parse::RecDescent::_trace(q{Trying terminal: ['log']},
3405							Parse::RecDescent::_tracefirst($text),
3406							q{function_name},
3407							$tracelevel)
3408							if defined $::RD_TRACE;
3409	4307					6258	undef $lastsep;
3410	4307					11275	$expectation->is(q{})->at($text);
3411
3412
3413	4307	50	66			55968	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Alog/)
	4307	100				43830
3414							{
3415	4275	50				12199	$text = $lastsep . $text if defined $lastsep;
3416
3417	4275					13188	$expectation->failed();
3418	4275	50				19458	Parse::RecDescent::_trace(qq{<>},
3419							Parse::RecDescent::_tracefirst($text))
3420							if defined $::RD_TRACE;
3421	4275					8699	last;
3422							}
3423	32					179	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3424	32					100	substr($text,0,length($current_match),q{});
3425	32	50				101	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3426							. $current_match . q{])},
3427							Parse::RecDescent::_tracefirst($text))
3428							if defined $::RD_TRACE;
3429	32					98	push @item, $item{__STRING1__}=$current_match;
3430
3431
3432	32	50				85	Parse::RecDescent::_trace(q{>>Matched production: ['log']<<},
3433							Parse::RecDescent::_tracefirst($text),
3434							q{function_name},
3435							$tracelevel)
3436							if defined $::RD_TRACE;
3437
3438
3439
3440	32					46	$_matched = 1;
3441	32					69	last;
3442							}
3443
3444
3445	4307		66			16609	while (!$_matched && !$commit)
3446							{
3447
3448	4275	50				8695	Parse::RecDescent::_trace(q{Trying production: ['partial_derivative']},
3449							Parse::RecDescent::_tracefirst($_[1]),
3450							q{function_name},
3451							$tracelevel)
3452							if defined $::RD_TRACE;
3453	4275					18786	my $thisprod = $thisrule->{"prods"}[1];
3454	4275					6849	$text = $_[1];
3455	4275					8750	my $_savetext;
3456	4275					9544	@item = (q{function_name});
3457	4275					11702	%item = (__RULE__ => q{function_name});
3458	4275					5648	my $repcount = 0;
3459
3460
3461	4275	50				8733	Parse::RecDescent::_trace(q{Trying terminal: ['partial_derivative']},
3462							Parse::RecDescent::_tracefirst($text),
3463							q{function_name},
3464							$tracelevel)
3465							if defined $::RD_TRACE;
3466	4275					5689	undef $lastsep;
3467	4275					14457	$expectation->is(q{})->at($text);
3468
3469
3470	4275	50	66			48519	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Apartial_derivative/)
	4275	100				32408
3471							{
3472	4031	50				11700	$text = $lastsep . $text if defined $lastsep;
3473
3474	4031					11482	$expectation->failed();
3475	4031	50				18223	Parse::RecDescent::_trace(qq{<>},
3476							Parse::RecDescent::_tracefirst($text))
3477							if defined $::RD_TRACE;
3478	4031					7931	last;
3479							}
3480	244					1379	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3481	244					907	substr($text,0,length($current_match),q{});
3482	244	50				699	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3483							. $current_match . q{])},
3484							Parse::RecDescent::_tracefirst($text))
3485							if defined $::RD_TRACE;
3486	244					667	push @item, $item{__STRING1__}=$current_match;
3487
3488
3489	244	50				537	Parse::RecDescent::_trace(q{>>Matched production: ['partial_derivative']<<},
3490							Parse::RecDescent::_tracefirst($text),
3491							q{function_name},
3492							$tracelevel)
3493							if defined $::RD_TRACE;
3494
3495
3496
3497	244					322	$_matched = 1;
3498	244					441	last;
3499							}
3500
3501
3502	4307		66			15767	while (!$_matched && !$commit)
3503							{
3504
3505	4031	50				8218	Parse::RecDescent::_trace(q{Trying production: ['total_derivative']},
3506							Parse::RecDescent::_tracefirst($_[1]),
3507							q{function_name},
3508							$tracelevel)
3509							if defined $::RD_TRACE;
3510	4031					8590	my $thisprod = $thisrule->{"prods"}[2];
3511	4031					6841	$text = $_[1];
3512	4031					4920	my $_savetext;
3513	4031					7532	@item = (q{function_name});
3514	4031					8484	%item = (__RULE__ => q{function_name});
3515	4031					5116	my $repcount = 0;
3516
3517
3518	4031	50				8799	Parse::RecDescent::_trace(q{Trying terminal: ['total_derivative']},
3519							Parse::RecDescent::_tracefirst($text),
3520							q{function_name},
3521							$tracelevel)
3522							if defined $::RD_TRACE;
3523	4031					5169	undef $lastsep;
3524	4031					11004	$expectation->is(q{})->at($text);
3525
3526
3527	4031	50	66			39160	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Atotal_derivative/)
	4031	100				31376
3528							{
3529	4005	50				11237	$text = $lastsep . $text if defined $lastsep;
3530
3531	4005					11905	$expectation->failed();
3532	4005	50				17049	Parse::RecDescent::_trace(qq{<>},
3533							Parse::RecDescent::_tracefirst($text))
3534							if defined $::RD_TRACE;
3535	4005					7778	last;
3536							}
3537	26					150	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3538	26					93	substr($text,0,length($current_match),q{});
3539	26	50				101	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3540							. $current_match . q{])},
3541							Parse::RecDescent::_tracefirst($text))
3542							if defined $::RD_TRACE;
3543	26					118	push @item, $item{__STRING1__}=$current_match;
3544
3545
3546	26	50				81	Parse::RecDescent::_trace(q{>>Matched production: ['total_derivative']<<},
3547							Parse::RecDescent::_tracefirst($text),
3548							q{function_name},
3549							$tracelevel)
3550							if defined $::RD_TRACE;
3551
3552
3553
3554	26					60	$_matched = 1;
3555	26					81	last;
3556							}
3557
3558
3559	4307		66			19725	while (!$_matched && !$commit)
3560							{
3561
3562	4005	50				7675	Parse::RecDescent::_trace(q{Trying production: ['sinh']},
3563							Parse::RecDescent::_tracefirst($_[1]),
3564							q{function_name},
3565							$tracelevel)
3566							if defined $::RD_TRACE;
3567	4005					8866	my $thisprod = $thisrule->{"prods"}[3];
3568	4005					6329	$text = $_[1];
3569	4005					4532	my $_savetext;
3570	4005					7341	@item = (q{function_name});
3571	4005					8911	%item = (__RULE__ => q{function_name});
3572	4005					7172	my $repcount = 0;
3573
3574
3575	4005	50				8363	Parse::RecDescent::_trace(q{Trying terminal: ['sinh']},
3576							Parse::RecDescent::_tracefirst($text),
3577							q{function_name},
3578							$tracelevel)
3579							if defined $::RD_TRACE;
3580	4005					4733	undef $lastsep;
3581	4005					11634	$expectation->is(q{})->at($text);
3582
3583
3584	4005	50	66			38129	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Asinh/)
	4005	100				31490
3585							{
3586	3995	50				12149	$text = $lastsep . $text if defined $lastsep;
3587
3588	3995					11591	$expectation->failed();
3589	3995	50				16864	Parse::RecDescent::_trace(qq{<>},
3590							Parse::RecDescent::_tracefirst($text))
3591							if defined $::RD_TRACE;
3592	3995					7438	last;
3593							}
3594	10					61	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3595	10					34	substr($text,0,length($current_match),q{});
3596	10	50				28	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3597							. $current_match . q{])},
3598							Parse::RecDescent::_tracefirst($text))
3599							if defined $::RD_TRACE;
3600	10					34	push @item, $item{__STRING1__}=$current_match;
3601
3602
3603	10	50				28	Parse::RecDescent::_trace(q{>>Matched production: ['sinh']<<},
3604							Parse::RecDescent::_tracefirst($text),
3605							q{function_name},
3606							$tracelevel)
3607							if defined $::RD_TRACE;
3608
3609
3610
3611	10					17	$_matched = 1;
3612	10					29	last;
3613							}
3614
3615
3616	4307		66			15635	while (!$_matched && !$commit)
3617							{
3618
3619	3995	50				8561	Parse::RecDescent::_trace(q{Trying production: ['cosh']},
3620							Parse::RecDescent::_tracefirst($_[1]),
3621							q{function_name},
3622							$tracelevel)
3623							if defined $::RD_TRACE;
3624	3995					7829	my $thisprod = $thisrule->{"prods"}[4];
3625	3995					5804	$text = $_[1];
3626	3995					4440	my $_savetext;
3627	3995					8466	@item = (q{function_name});
3628	3995					8831	%item = (__RULE__ => q{function_name});
3629	3995					4859	my $repcount = 0;
3630
3631
3632	3995	50				8108	Parse::RecDescent::_trace(q{Trying terminal: ['cosh']},
3633							Parse::RecDescent::_tracefirst($text),
3634							q{function_name},
3635							$tracelevel)
3636							if defined $::RD_TRACE;
3637	3995					4998	undef $lastsep;
3638	3995					11287	$expectation->is(q{})->at($text);
3639
3640
3641	3995	50	66			39950	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Acosh/)
	3995	100				30976
3642							{
3643	3985	50				11239	$text = $lastsep . $text if defined $lastsep;
3644
3645	3985					16312	$expectation->failed();
3646	3985	50				16899	Parse::RecDescent::_trace(qq{<>},
3647							Parse::RecDescent::_tracefirst($text))
3648							if defined $::RD_TRACE;
3649	3985					7361	last;
3650							}
3651	10					48	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3652	10					32	substr($text,0,length($current_match),q{});
3653	10	50				25	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3654							. $current_match . q{])},
3655							Parse::RecDescent::_tracefirst($text))
3656							if defined $::RD_TRACE;
3657	10					24	push @item, $item{__STRING1__}=$current_match;
3658
3659
3660	10	50				21	Parse::RecDescent::_trace(q{>>Matched production: ['cosh']<<},
3661							Parse::RecDescent::_tracefirst($text),
3662							q{function_name},
3663							$tracelevel)
3664							if defined $::RD_TRACE;
3665
3666
3667
3668	10					12	$_matched = 1;
3669	10					21	last;
3670							}
3671
3672
3673	4307		66			16141	while (!$_matched && !$commit)
3674							{
3675
3676	3985	50				14789	Parse::RecDescent::_trace(q{Trying production: ['asinh']},
3677							Parse::RecDescent::_tracefirst($_[1]),
3678							q{function_name},
3679							$tracelevel)
3680							if defined $::RD_TRACE;
3681	3985					7963	my $thisprod = $thisrule->{"prods"}[5];
3682	3985					6396	$text = $_[1];
3683	3985					4391	my $_savetext;
3684	3985					7334	@item = (q{function_name});
3685	3985					8597	%item = (__RULE__ => q{function_name});
3686	3985					4857	my $repcount = 0;
3687
3688
3689	3985	50				8458	Parse::RecDescent::_trace(q{Trying terminal: ['asinh']},
3690							Parse::RecDescent::_tracefirst($text),
3691							q{function_name},
3692							$tracelevel)
3693							if defined $::RD_TRACE;
3694	3985					4878	undef $lastsep;
3695	3985					10688	$expectation->is(q{})->at($text);
3696
3697
3698	3985	50	66			38458	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aasinh/)
	3985	100				29395
3699							{
3700	3983	50				11421	$text = $lastsep . $text if defined $lastsep;
3701
3702	3983					11697	$expectation->failed();
3703	3983	50				17111	Parse::RecDescent::_trace(qq{<>},
3704							Parse::RecDescent::_tracefirst($text))
3705							if defined $::RD_TRACE;
3706	3983					7530	last;
3707							}
3708	2					11	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3709	2					7	substr($text,0,length($current_match),q{});
3710	2	50				8	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3711							. $current_match . q{])},
3712							Parse::RecDescent::_tracefirst($text))
3713							if defined $::RD_TRACE;
3714	2					5	push @item, $item{__STRING1__}=$current_match;
3715
3716
3717	2	50				8	Parse::RecDescent::_trace(q{>>Matched production: ['asinh']<<},
3718							Parse::RecDescent::_tracefirst($text),
3719							q{function_name},
3720							$tracelevel)
3721							if defined $::RD_TRACE;
3722
3723
3724
3725	2					5	$_matched = 1;
3726	2					3	last;
3727							}
3728
3729
3730	4307		66			16139	while (!$_matched && !$commit)
3731							{
3732
3733	3983	50				7520	Parse::RecDescent::_trace(q{Trying production: ['acosh']},
3734							Parse::RecDescent::_tracefirst($_[1]),
3735							q{function_name},
3736							$tracelevel)
3737							if defined $::RD_TRACE;
3738	3983					7847	my $thisprod = $thisrule->{"prods"}[6];
3739	3983					6319	$text = $_[1];
3740	3983					5253	my $_savetext;
3741	3983					7724	@item = (q{function_name});
3742	3983					8533	%item = (__RULE__ => q{function_name});
3743	3983					5201	my $repcount = 0;
3744
3745
3746	3983	50				13827	Parse::RecDescent::_trace(q{Trying terminal: ['acosh']},
3747							Parse::RecDescent::_tracefirst($text),
3748							q{function_name},
3749							$tracelevel)
3750							if defined $::RD_TRACE;
3751	3983					5208	undef $lastsep;
3752	3983					11256	$expectation->is(q{})->at($text);
3753
3754
3755	3983	50	66			37131	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aacosh/)
	3983	100				30117
3756							{
3757	3981	50				15099	$text = $lastsep . $text if defined $lastsep;
3758
3759	3981					11295	$expectation->failed();
3760	3981	50				17349	Parse::RecDescent::_trace(qq{<>},
3761							Parse::RecDescent::_tracefirst($text))
3762							if defined $::RD_TRACE;
3763	3981					8188	last;
3764							}
3765	2					13	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3766	2					10	substr($text,0,length($current_match),q{});
3767	2	50				7	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3768							. $current_match . q{])},
3769							Parse::RecDescent::_tracefirst($text))
3770							if defined $::RD_TRACE;
3771	2					7	push @item, $item{__STRING1__}=$current_match;
3772
3773
3774	2	50				7	Parse::RecDescent::_trace(q{>>Matched production: ['acosh']<<},
3775							Parse::RecDescent::_tracefirst($text),
3776							q{function_name},
3777							$tracelevel)
3778							if defined $::RD_TRACE;
3779
3780
3781
3782	2					4	$_matched = 1;
3783	2					6	last;
3784							}
3785
3786
3787	4307		66			21286	while (!$_matched && !$commit)
3788							{
3789
3790	3981	50				8008	Parse::RecDescent::_trace(q{Trying production: ['asin']},
3791							Parse::RecDescent::_tracefirst($_[1]),
3792							q{function_name},
3793							$tracelevel)
3794							if defined $::RD_TRACE;
3795	3981					7601	my $thisprod = $thisrule->{"prods"}[7];
3796	3981					6058	$text = $_[1];
3797	3981					4343	my $_savetext;
3798	3981					7571	@item = (q{function_name});
3799	3981					8566	%item = (__RULE__ => q{function_name});
3800	3981					5219	my $repcount = 0;
3801
3802
3803	3981	50				7680	Parse::RecDescent::_trace(q{Trying terminal: ['asin']},
3804							Parse::RecDescent::_tracefirst($text),
3805							q{function_name},
3806							$tracelevel)
3807							if defined $::RD_TRACE;
3808	3981					4947	undef $lastsep;
3809	3981					10820	$expectation->is(q{})->at($text);
3810
3811
3812	3981	50	66			37039	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aasin/)
	3981	100				55922
3813							{
3814	3979	50				11672	$text = $lastsep . $text if defined $lastsep;
3815
3816	3979					12309	$expectation->failed();
3817	3979	50				16277	Parse::RecDescent::_trace(qq{<>},
3818							Parse::RecDescent::_tracefirst($text))
3819							if defined $::RD_TRACE;
3820	3979					7319	last;
3821							}
3822	2					12	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3823	2					8	substr($text,0,length($current_match),q{});
3824	2	50				7	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3825							. $current_match . q{])},
3826							Parse::RecDescent::_tracefirst($text))
3827							if defined $::RD_TRACE;
3828	2					8	push @item, $item{__STRING1__}=$current_match;
3829
3830
3831	2	50				5	Parse::RecDescent::_trace(q{>>Matched production: ['asin']<<},
3832							Parse::RecDescent::_tracefirst($text),
3833							q{function_name},
3834							$tracelevel)
3835							if defined $::RD_TRACE;
3836
3837
3838
3839	2					3	$_matched = 1;
3840	2					5	last;
3841							}
3842
3843
3844	4307		66			16439	while (!$_matched && !$commit)
3845							{
3846
3847	3979	50				7427	Parse::RecDescent::_trace(q{Trying production: ['acos']},
3848							Parse::RecDescent::_tracefirst($_[1]),
3849							q{function_name},
3850							$tracelevel)
3851							if defined $::RD_TRACE;
3852	3979					7749	my $thisprod = $thisrule->{"prods"}[8];
3853	3979					5887	$text = $_[1];
3854	3979					5264	my $_savetext;
3855	3979					7477	@item = (q{function_name});
3856	3979					8986	%item = (__RULE__ => q{function_name});
3857	3979					5078	my $repcount = 0;
3858
3859
3860	3979	50				7923	Parse::RecDescent::_trace(q{Trying terminal: ['acos']},
3861							Parse::RecDescent::_tracefirst($text),
3862							q{function_name},
3863							$tracelevel)
3864							if defined $::RD_TRACE;
3865	3979					4687	undef $lastsep;
3866	3979					10565	$expectation->is(q{})->at($text);
3867
3868
3869	3979	50	66			51274	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aacos/)
	3979	100				29611
3870							{
3871	3975	50				11163	$text = $lastsep . $text if defined $lastsep;
3872
3873	3975					11690	$expectation->failed();
3874	3975	50				16961	Parse::RecDescent::_trace(qq{<>},
3875							Parse::RecDescent::_tracefirst($text))
3876							if defined $::RD_TRACE;
3877	3975					7236	last;
3878							}
3879	4					25	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3880	4					15	substr($text,0,length($current_match),q{});
3881	4	50				14	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3882							. $current_match . q{])},
3883							Parse::RecDescent::_tracefirst($text))
3884							if defined $::RD_TRACE;
3885	4					12	push @item, $item{__STRING1__}=$current_match;
3886
3887
3888	4	50				13	Parse::RecDescent::_trace(q{>>Matched production: ['acos']<<},
3889							Parse::RecDescent::_tracefirst($text),
3890							q{function_name},
3891							$tracelevel)
3892							if defined $::RD_TRACE;
3893
3894
3895
3896	4					6	$_matched = 1;
3897	4					10	last;
3898							}
3899
3900
3901	4307		66			17835	while (!$_matched && !$commit)
3902							{
3903
3904	3975	50				7597	Parse::RecDescent::_trace(q{Trying production: ['atan2']},
3905							Parse::RecDescent::_tracefirst($_[1]),
3906							q{function_name},
3907							$tracelevel)
3908							if defined $::RD_TRACE;
3909	3975					7731	my $thisprod = $thisrule->{"prods"}[9];
3910	3975					5767	$text = $_[1];
3911	3975					4333	my $_savetext;
3912	3975					8155	@item = (q{function_name});
3913	3975					8541	%item = (__RULE__ => q{function_name});
3914	3975					5200	my $repcount = 0;
3915
3916
3917	3975	50				7924	Parse::RecDescent::_trace(q{Trying terminal: ['atan2']},
3918							Parse::RecDescent::_tracefirst($text),
3919							q{function_name},
3920							$tracelevel)
3921							if defined $::RD_TRACE;
3922	3975					5003	undef $lastsep;
3923	3975					11122	$expectation->is(q{})->at($text);
3924
3925
3926	3975	50	33			42070	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aatan2/)
	3975	50				29845
3927							{
3928	3975	50				11146	$text = $lastsep . $text if defined $lastsep;
3929
3930	3975					11757	$expectation->failed();
3931	3975	50				26437	Parse::RecDescent::_trace(qq{<>},
3932							Parse::RecDescent::_tracefirst($text))
3933							if defined $::RD_TRACE;
3934	3975					8738	last;
3935							}
3936	0					0	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3937	0					0	substr($text,0,length($current_match),q{});
3938	0	0				0	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3939							. $current_match . q{])},
3940							Parse::RecDescent::_tracefirst($text))
3941							if defined $::RD_TRACE;
3942	0					0	push @item, $item{__STRING1__}=$current_match;
3943
3944
3945	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: ['atan2']<<},
3946							Parse::RecDescent::_tracefirst($text),
3947							q{function_name},
3948							$tracelevel)
3949							if defined $::RD_TRACE;
3950
3951
3952
3953	0					0	$_matched = 1;
3954	0					0	last;
3955							}
3956
3957
3958	4307		66			15530	while (!$_matched && !$commit)
3959							{
3960
3961	3975	50				10755	Parse::RecDescent::_trace(q{Trying production: ['atan']},
3962							Parse::RecDescent::_tracefirst($_[1]),
3963							q{function_name},
3964							$tracelevel)
3965							if defined $::RD_TRACE;
3966	3975					8226	my $thisprod = $thisrule->{"prods"}[10];
3967	3975					5911	$text = $_[1];
3968	3975					4217	my $_savetext;
3969	3975					7794	@item = (q{function_name});
3970	3975					12329	%item = (__RULE__ => q{function_name});
3971	3975					5198	my $repcount = 0;
3972
3973
3974	3975	50				7458	Parse::RecDescent::_trace(q{Trying terminal: ['atan']},
3975							Parse::RecDescent::_tracefirst($text),
3976							q{function_name},
3977							$tracelevel)
3978							if defined $::RD_TRACE;
3979	3975					5070	undef $lastsep;
3980	3975					11364	$expectation->is(q{})->at($text);
3981
3982
3983	3975	50	66			40413	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aatan/)
	3975	100				30894
3984							{
3985	3973	50				11190	$text = $lastsep . $text if defined $lastsep;
3986
3987	3973					11103	$expectation->failed();
3988	3973	50				21416	Parse::RecDescent::_trace(qq{<>},
3989							Parse::RecDescent::_tracefirst($text))
3990							if defined $::RD_TRACE;
3991	3973					7893	last;
3992							}
3993	2					9	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3994	2					7	substr($text,0,length($current_match),q{});
3995	2	50				7	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3996							. $current_match . q{])},
3997							Parse::RecDescent::_tracefirst($text))
3998							if defined $::RD_TRACE;
3999	2					6	push @item, $item{__STRING1__}=$current_match;
4000
4001
4002	2	50				5	Parse::RecDescent::_trace(q{>>Matched production: ['atan']<<},
4003							Parse::RecDescent::_tracefirst($text),
4004							q{function_name},
4005							$tracelevel)
4006							if defined $::RD_TRACE;
4007
4008
4009
4010	2					4	$_matched = 1;
4011	2					4	last;
4012							}
4013
4014
4015	4307		66			16333	while (!$_matched && !$commit)
4016							{
4017
4018	3973	50				7809	Parse::RecDescent::_trace(q{Trying production: ['acot']},
4019							Parse::RecDescent::_tracefirst($_[1]),
4020							q{function_name},
4021							$tracelevel)
4022							if defined $::RD_TRACE;
4023	3973					8339	my $thisprod = $thisrule->{"prods"}[11];
4024	3973					6337	$text = $_[1];
4025	3973					4513	my $_savetext;
4026	3973					7050	@item = (q{function_name});
4027	3973					8330	%item = (__RULE__ => q{function_name});
4028	3973					4947	my $repcount = 0;
4029
4030
4031	3973	50				7775	Parse::RecDescent::_trace(q{Trying terminal: ['acot']},
4032							Parse::RecDescent::_tracefirst($text),
4033							q{function_name},
4034							$tracelevel)
4035							if defined $::RD_TRACE;
4036	3973					4916	undef $lastsep;
4037	3973					10964	$expectation->is(q{})->at($text);
4038
4039
4040	3973	50	66			37583	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aacot/)
	3973	100				33098
4041							{
4042	3971	50				11631	$text = $lastsep . $text if defined $lastsep;
4043
4044	3971					12064	$expectation->failed();
4045	3971	50				17509	Parse::RecDescent::_trace(qq{<>},
4046							Parse::RecDescent::_tracefirst($text))
4047							if defined $::RD_TRACE;
4048	3971					7330	last;
4049							}
4050	2					11	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4051	2					8	substr($text,0,length($current_match),q{});
4052	2	50				8	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4053							. $current_match . q{])},
4054							Parse::RecDescent::_tracefirst($text))
4055							if defined $::RD_TRACE;
4056	2					6	push @item, $item{__STRING1__}=$current_match;
4057
4058
4059	2	50				6	Parse::RecDescent::_trace(q{>>Matched production: ['acot']<<},
4060							Parse::RecDescent::_tracefirst($text),
4061							q{function_name},
4062							$tracelevel)
4063							if defined $::RD_TRACE;
4064
4065
4066
4067	2					4	$_matched = 1;
4068	2					4	last;
4069							}
4070
4071
4072	4307		66			14757	while (!$_matched && !$commit)
4073							{
4074
4075	3971	50				8186	Parse::RecDescent::_trace(q{Trying production: ['sin']},
4076							Parse::RecDescent::_tracefirst($_[1]),
4077							q{function_name},
4078							$tracelevel)
4079							if defined $::RD_TRACE;
4080	3971					7471	my $thisprod = $thisrule->{"prods"}[12];
4081	3971					6362	$text = $_[1];
4082	3971					4458	my $_savetext;
4083	3971					7144	@item = (q{function_name});
4084	3971					8578	%item = (__RULE__ => q{function_name});
4085	3971					4869	my $repcount = 0;
4086
4087
4088	3971	50				8309	Parse::RecDescent::_trace(q{Trying terminal: ['sin']},
4089							Parse::RecDescent::_tracefirst($text),
4090							q{function_name},
4091							$tracelevel)
4092							if defined $::RD_TRACE;
4093	3971					5148	undef $lastsep;
4094	3971					11106	$expectation->is(q{})->at($text);
4095
4096
4097	3971	50	66			42169	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Asin/)
	3971	100				29359
4098							{
4099	3877	50				10161	$text = $lastsep . $text if defined $lastsep;
4100
4101	3877					10878	$expectation->failed();
4102	3877	50				16057	Parse::RecDescent::_trace(qq{<>},
4103							Parse::RecDescent::_tracefirst($text))
4104							if defined $::RD_TRACE;
4105	3877					6791	last;
4106							}
4107	94					592	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4108	94					352	substr($text,0,length($current_match),q{});
4109	94	50				266	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4110							. $current_match . q{])},
4111							Parse::RecDescent::_tracefirst($text))
4112							if defined $::RD_TRACE;
4113	94					273	push @item, $item{__STRING1__}=$current_match;
4114
4115
4116	94	50				246	Parse::RecDescent::_trace(q{>>Matched production: ['sin']<<},
4117							Parse::RecDescent::_tracefirst($text),
4118							q{function_name},
4119							$tracelevel)
4120							if defined $::RD_TRACE;
4121
4122
4123
4124	94					127	$_matched = 1;
4125	94					176	last;
4126							}
4127
4128
4129	4307		66			14694	while (!$_matched && !$commit)
4130							{
4131
4132	3877	50				7220	Parse::RecDescent::_trace(q{Trying production: ['cos']},
4133							Parse::RecDescent::_tracefirst($_[1]),
4134							q{function_name},
4135							$tracelevel)
4136							if defined $::RD_TRACE;
4137	3877					9299	my $thisprod = $thisrule->{"prods"}[13];
4138	3877					5724	$text = $_[1];
4139	3877					4551	my $_savetext;
4140	3877					11893	@item = (q{function_name});
4141	3877					8038	%item = (__RULE__ => q{function_name});
4142	3877					4630	my $repcount = 0;
4143
4144
4145	3877	50				7654	Parse::RecDescent::_trace(q{Trying terminal: ['cos']},
4146							Parse::RecDescent::_tracefirst($text),
4147							q{function_name},
4148							$tracelevel)
4149							if defined $::RD_TRACE;
4150	3877					5779	undef $lastsep;
4151	3877					10366	$expectation->is(q{})->at($text);
4152
4153
4154	3877	50	66			35648	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Acos/)
	3877	100				28494
4155							{
4156	3839	50				10721	$text = $lastsep . $text if defined $lastsep;
4157
4158	3839					11826	$expectation->failed();
4159	3839	50				16036	Parse::RecDescent::_trace(qq{<>},
4160							Parse::RecDescent::_tracefirst($text))
4161							if defined $::RD_TRACE;
4162	3839					7671	last;
4163							}
4164	38					238	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4165	38					141	substr($text,0,length($current_match),q{});
4166	38	50				117	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4167							. $current_match . q{])},
4168							Parse::RecDescent::_tracefirst($text))
4169							if defined $::RD_TRACE;
4170	38					155	push @item, $item{__STRING1__}=$current_match;
4171
4172
4173	38	50				82	Parse::RecDescent::_trace(q{>>Matched production: ['cos']<<},
4174							Parse::RecDescent::_tracefirst($text),
4175							q{function_name},
4176							$tracelevel)
4177							if defined $::RD_TRACE;
4178
4179
4180
4181	38					50	$_matched = 1;
4182	38					87	last;
4183							}
4184
4185
4186	4307		66			14974	while (!$_matched && !$commit)
4187							{
4188
4189	3839	50				7159	Parse::RecDescent::_trace(q{Trying production: ['tan']},
4190							Parse::RecDescent::_tracefirst($_[1]),
4191							q{function_name},
4192							$tracelevel)
4193							if defined $::RD_TRACE;
4194	3839					7238	my $thisprod = $thisrule->{"prods"}[14];
4195	3839					5561	$text = $_[1];
4196	3839					4119	my $_savetext;
4197	3839					11805	@item = (q{function_name});
4198	3839					8330	%item = (__RULE__ => q{function_name});
4199	3839					4708	my $repcount = 0;
4200
4201
4202	3839	50				7118	Parse::RecDescent::_trace(q{Trying terminal: ['tan']},
4203							Parse::RecDescent::_tracefirst($text),
4204							q{function_name},
4205							$tracelevel)
4206							if defined $::RD_TRACE;
4207	3839					6236	undef $lastsep;
4208	3839					10213	$expectation->is(q{})->at($text);
4209
4210
4211	3839	50	66			35305	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Atan/)
	3839	100				29667
4212							{
4213	3827	50				11065	$text = $lastsep . $text if defined $lastsep;
4214
4215	3827					10912	$expectation->failed();
4216	3827	50				16065	Parse::RecDescent::_trace(qq{<>},
4217							Parse::RecDescent::_tracefirst($text))
4218							if defined $::RD_TRACE;
4219	3827					9074	last;
4220							}
4221	12					73	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4222	12					70	substr($text,0,length($current_match),q{});
4223	12	50				32	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4224							. $current_match . q{])},
4225							Parse::RecDescent::_tracefirst($text))
4226							if defined $::RD_TRACE;
4227	12					46	push @item, $item{__STRING1__}=$current_match;
4228
4229
4230	12	50				37	Parse::RecDescent::_trace(q{>>Matched production: ['tan']<<},
4231							Parse::RecDescent::_tracefirst($text),
4232							q{function_name},
4233							$tracelevel)
4234							if defined $::RD_TRACE;
4235
4236
4237
4238	12					28	$_matched = 1;
4239	12					23	last;
4240							}
4241
4242
4243	4307		66			15043	while (!$_matched && !$commit)
4244							{
4245
4246	3827	50				7304	Parse::RecDescent::_trace(q{Trying production: ['cot']},
4247							Parse::RecDescent::_tracefirst($_[1]),
4248							q{function_name},
4249							$tracelevel)
4250							if defined $::RD_TRACE;
4251	3827					8011	my $thisprod = $thisrule->{"prods"}[15];
4252	3827					5907	$text = $_[1];
4253	3827					4355	my $_savetext;
4254	3827					7283	@item = (q{function_name});
4255	3827					8654	%item = (__RULE__ => q{function_name});
4256	3827					4950	my $repcount = 0;
4257
4258
4259	3827	50				7136	Parse::RecDescent::_trace(q{Trying terminal: ['cot']},
4260							Parse::RecDescent::_tracefirst($text),
4261							q{function_name},
4262							$tracelevel)
4263							if defined $::RD_TRACE;
4264	3827					4630	undef $lastsep;
4265	3827					23999	$expectation->is(q{})->at($text);
4266
4267
4268	3827	50	66			36692	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Acot/)
	3827	100				28076
4269							{
4270	3825	50				10426	$text = $lastsep . $text if defined $lastsep;
4271
4272	3825					11335	$expectation->failed();
4273	3825	50				15958	Parse::RecDescent::_trace(qq{<>},
4274							Parse::RecDescent::_tracefirst($text))
4275							if defined $::RD_TRACE;
4276	3825					7357	last;
4277							}
4278	2					17	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4279	2					10	substr($text,0,length($current_match),q{});
4280	2	50				6	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4281							. $current_match . q{])},
4282							Parse::RecDescent::_tracefirst($text))
4283							if defined $::RD_TRACE;
4284	2					9	push @item, $item{__STRING1__}=$current_match;
4285
4286
4287	2	50				6	Parse::RecDescent::_trace(q{>>Matched production: ['cot']<<},
4288							Parse::RecDescent::_tracefirst($text),
4289							q{function_name},
4290							$tracelevel)
4291							if defined $::RD_TRACE;
4292
4293
4294
4295	2					4	$_matched = 1;
4296	2					6	last;
4297							}
4298
4299
4300	4307		66			15667	while (!$_matched && !$commit)
4301							{
4302
4303	3825	50				7895	Parse::RecDescent::_trace(q{Trying production: ['exp']},
4304							Parse::RecDescent::_tracefirst($_[1]),
4305							q{function_name},
4306							$tracelevel)
4307							if defined $::RD_TRACE;
4308	3825					7191	my $thisprod = $thisrule->{"prods"}[16];
4309	3825					5835	$text = $_[1];
4310	3825					4061	my $_savetext;
4311	3825					7054	@item = (q{function_name});
4312	3825					7911	%item = (__RULE__ => q{function_name});
4313	3825					4832	my $repcount = 0;
4314
4315
4316	3825	50				7360	Parse::RecDescent::_trace(q{Trying terminal: ['exp']},
4317							Parse::RecDescent::_tracefirst($text),
4318							q{function_name},
4319							$tracelevel)
4320							if defined $::RD_TRACE;
4321	3825					4877	undef $lastsep;
4322	3825					9748	$expectation->is(q{})->at($text);
4323
4324
4325	3825	50	66			35155	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aexp/)
	3825	100				34822
4326							{
4327	3819	50				10542	$text = $lastsep . $text if defined $lastsep;
4328
4329	3819					16951	$expectation->failed();
4330	3819	50				16297	Parse::RecDescent::_trace(qq{<>},
4331							Parse::RecDescent::_tracefirst($text))
4332							if defined $::RD_TRACE;
4333	3819					11205	last;
4334							}
4335	6					33	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4336	6					21	substr($text,0,length($current_match),q{});
4337	6	50				19	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4338							. $current_match . q{])},
4339							Parse::RecDescent::_tracefirst($text))
4340							if defined $::RD_TRACE;
4341	6					18	push @item, $item{__STRING1__}=$current_match;
4342
4343
4344	6	50				19	Parse::RecDescent::_trace(q{>>Matched production: ['exp']<<},
4345							Parse::RecDescent::_tracefirst($text),
4346							q{function_name},
4347							$tracelevel)
4348							if defined $::RD_TRACE;
4349
4350
4351
4352	6					6	$_matched = 1;
4353	6					11	last;
4354							}
4355
4356
4357	4307		66			20787	while (!$_matched && !$commit)
4358							{
4359
4360	3819	50				7760	Parse::RecDescent::_trace(q{Trying production: ['sqrt']},
4361							Parse::RecDescent::_tracefirst($_[1]),
4362							q{function_name},
4363							$tracelevel)
4364							if defined $::RD_TRACE;
4365	3819					7183	my $thisprod = $thisrule->{"prods"}[17];
4366	3819					5820	$text = $_[1];
4367	3819					4170	my $_savetext;
4368	3819					8323	@item = (q{function_name});
4369	3819					8073	%item = (__RULE__ => q{function_name});
4370	3819					4511	my $repcount = 0;
4371
4372
4373	3819	50				9947	Parse::RecDescent::_trace(q{Trying terminal: ['sqrt']},
4374							Parse::RecDescent::_tracefirst($text),
4375							q{function_name},
4376							$tracelevel)
4377							if defined $::RD_TRACE;
4378	3819					5145	undef $lastsep;
4379	3819					10754	$expectation->is(q{})->at($text);
4380
4381
4382	3819	50	66			36637	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Asqrt/)
	3819	100				28867
4383							{
4384	3817	50				10746	$text = $lastsep . $text if defined $lastsep;
4385
4386	3817					10915	$expectation->failed();
4387	3817	50				15477	Parse::RecDescent::_trace(qq{<>},
4388							Parse::RecDescent::_tracefirst($text))
4389							if defined $::RD_TRACE;
4390	3817					7785	last;
4391							}
4392	2					8	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4393	2					6	substr($text,0,length($current_match),q{});
4394	2	50				6	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4395							. $current_match . q{])},
4396							Parse::RecDescent::_tracefirst($text))
4397							if defined $::RD_TRACE;
4398	2					6	push @item, $item{__STRING1__}=$current_match;
4399
4400
4401	2	50				5	Parse::RecDescent::_trace(q{>>Matched production: ['sqrt']<<},
4402							Parse::RecDescent::_tracefirst($text),
4403							q{function_name},
4404							$tracelevel)
4405							if defined $::RD_TRACE;
4406
4407
4408
4409	2					3	$_matched = 1;
4410	2					4	last;
4411							}
4412
4413
4414	4307	100	66			18850	unless ( $_matched \|\| defined($score) )
4415							{
4416
4417
4418	3817					6308	$_[1] = $text; # NOT SURE THIS IS NEEDED
4419	3817	50				8027	Parse::RecDescent::_trace(q{<>},
4420							Parse::RecDescent::_tracefirst($_[1]),
4421							q{function_name},
4422							$tracelevel)
4423							if defined $::RD_TRACE;
4424	3817					34960	return undef;
4425							}
4426	490	50	33			2471	if (!defined($return) && defined($score))
4427							{
4428	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4429							q{function_name},
4430							$tracelevel)
4431							if defined $::RD_TRACE;
4432	0					0	$return = $score_return;
4433							}
4434	490					764	splice @{$thisparser->{errors}}, $err_at;
	490					1467
4435	490	50				1651	$return = $item[$#item] unless defined $return;
4436	490	50				1542	if (defined $::RD_TRACE)
4437							{
4438	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4439							$return . q{])}, "",
4440							q{function_name},
4441							$tracelevel);
4442	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
4443							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4444							Parse::RecDescent::_tracefirst($text),
4445							, q{function_name},
4446							$tracelevel)
4447							}
4448	490					962	$_[1] = $text;
4449	490					4292	return $return;
4450							}
4451
4452							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
4453							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::add_op
4454							{
4455	2262			2262		3621	my $thisparser = $_[0];
4456	23			23		307	use vars q{$tracelevel};
	23					57
	23					37250
4457	2262		50			6970	local $tracelevel = ($tracelevel\|\|0)+1;
4458	2262					3006	$ERRORS = 0;
4459	2262					5698	my $thisrule = $thisparser->{"rules"}{"add_op"};
4460
4461	2262	50				5125	Parse::RecDescent::_trace(q{Trying rule: [add_op]},
4462							Parse::RecDescent::_tracefirst($_[1]),
4463							q{add_op},
4464							$tracelevel)
4465							if defined $::RD_TRACE;
4466
4467
4468	2262					2616	my $err_at = @{$thisparser->{errors}};
	2262					5040
4469
4470	2262					3387	my $score;
4471							my $score_return;
4472	0					0	my $_tok;
4473	2262					2913	my $return = undef;
4474	2262					2779	my $_matched=0;
4475	2262					3093	my $commit=0;
4476	2262					3748	my @item = ();
4477	2262					8792	my %item = ();
4478	2262					3004	my $repeating = $_[2];
4479	2262					3190	my $_noactions = $_[3];
4480	2262	50				5118	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2262					6330
	2262					5295
4481	2262					22811	my $_itempos = $_[5];
4482	2262	50				6728	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4483	2262					3257	my $text;
4484							my $lastsep;
4485	0					0	my $current_match;
4486	2262					7528	my $expectation = new Parse::RecDescent::Expectation(q{'+', or '-'});
4487	2262					18967	$expectation->at($_[1]);
4488
4489	2262					9670	my $thisline;
4490	2262					10342	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4491
4492
4493
4494	2262		33			28335	while (!$_matched && !$commit)
4495							{
4496
4497	2262	50				5046	Parse::RecDescent::_trace(q{Trying production: ['+']},
4498							Parse::RecDescent::_tracefirst($_[1]),
4499							q{add_op},
4500							$tracelevel)
4501							if defined $::RD_TRACE;
4502	2262					5478	my $thisprod = $thisrule->{"prods"}[0];
4503	2262					13230	$text = $_[1];
4504	2262					2710	my $_savetext;
4505	2262					4482	@item = (q{add_op});
4506	2262					8069	%item = (__RULE__ => q{add_op});
4507	2262					3064	my $repcount = 0;
4508
4509
4510	2262	50				4847	Parse::RecDescent::_trace(q{Trying terminal: ['+']},
4511							Parse::RecDescent::_tracefirst($text),
4512							q{add_op},
4513							$tracelevel)
4514							if defined $::RD_TRACE;
4515	2262					3054	undef $lastsep;
4516	2262					7094	$expectation->is(q{})->at($text);
4517
4518
4519	2262	50	66			25309	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\+/)
	2262	100				20351
4520							{
4521	1889	50				6233	$text = $lastsep . $text if defined $lastsep;
4522
4523	1889					6721	$expectation->failed();
4524	1889	50				9559	Parse::RecDescent::_trace(qq{<>},
4525							Parse::RecDescent::_tracefirst($text))
4526							if defined $::RD_TRACE;
4527	1889					3842	last;
4528							}
4529	373					2136	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4530	373					1204	substr($text,0,length($current_match),q{});
4531	373	50				993	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4532							. $current_match . q{])},
4533							Parse::RecDescent::_tracefirst($text))
4534							if defined $::RD_TRACE;
4535	373					1110	push @item, $item{__STRING1__}=$current_match;
4536
4537
4538	373	50				911	Parse::RecDescent::_trace(q{>>Matched production: ['+']<<},
4539							Parse::RecDescent::_tracefirst($text),
4540							q{add_op},
4541							$tracelevel)
4542							if defined $::RD_TRACE;
4543
4544
4545
4546	373					478	$_matched = 1;
4547	373					782	last;
4548							}
4549
4550
4551	2262		66			9674	while (!$_matched && !$commit)
4552							{
4553
4554	1889	50				8117	Parse::RecDescent::_trace(q{Trying production: ['-']},
4555							Parse::RecDescent::_tracefirst($_[1]),
4556							q{add_op},
4557							$tracelevel)
4558							if defined $::RD_TRACE;
4559	1889					3953	my $thisprod = $thisrule->{"prods"}[1];
4560	1889					3129	$text = $_[1];
4561	1889					2273	my $_savetext;
4562	1889					4078	@item = (q{add_op});
4563	1889					4788	%item = (__RULE__ => q{add_op});
4564	1889					2562	my $repcount = 0;
4565
4566
4567	1889	50				3860	Parse::RecDescent::_trace(q{Trying terminal: ['-']},
4568							Parse::RecDescent::_tracefirst($text),
4569							q{add_op},
4570							$tracelevel)
4571							if defined $::RD_TRACE;
4572	1889					2747	undef $lastsep;
4573	1889					5355	$expectation->is(q{})->at($text);
4574
4575
4576	1889	50	66			20577	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\-/)
	1889	100				18377
4577							{
4578	1772	50				5297	$text = $lastsep . $text if defined $lastsep;
4579
4580	1772					6173	$expectation->failed();
4581	1772	50				7933	Parse::RecDescent::_trace(qq{<>},
4582							Parse::RecDescent::_tracefirst($text))
4583							if defined $::RD_TRACE;
4584	1772					3557	last;
4585							}
4586	117					715	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4587	117					419	substr($text,0,length($current_match),q{});
4588	117	50				448	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4589							. $current_match . q{])},
4590							Parse::RecDescent::_tracefirst($text))
4591							if defined $::RD_TRACE;
4592	117					426	push @item, $item{__STRING1__}=$current_match;
4593
4594
4595	117	50				419	Parse::RecDescent::_trace(q{>>Matched production: ['-']<<},
4596							Parse::RecDescent::_tracefirst($text),
4597							q{add_op},
4598							$tracelevel)
4599							if defined $::RD_TRACE;
4600
4601
4602
4603	117					296	$_matched = 1;
4604	117					288	last;
4605							}
4606
4607
4608	2262	100	66			9947	unless ( $_matched \|\| defined($score) )
4609							{
4610
4611
4612	1772					3133	$_[1] = $text; # NOT SURE THIS IS NEEDED
4613	1772	50				3816	Parse::RecDescent::_trace(q{<>},
4614							Parse::RecDescent::_tracefirst($_[1]),
4615							q{add_op},
4616							$tracelevel)
4617							if defined $::RD_TRACE;
4618	1772					13971	return undef;
4619							}
4620	490	50	33			2678	if (!defined($return) && defined($score))
4621							{
4622	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4623							q{add_op},
4624							$tracelevel)
4625							if defined $::RD_TRACE;
4626	0					0	$return = $score_return;
4627							}
4628	490					989	splice @{$thisparser->{errors}}, $err_at;
	490					1396
4629	490	50				1546	$return = $item[$#item] unless defined $return;
4630	490	50				1370	if (defined $::RD_TRACE)
4631							{
4632	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4633							$return . q{])}, "",
4634							q{add_op},
4635							$tracelevel);
4636	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
4637							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4638							Parse::RecDescent::_tracefirst($text),
4639							, q{add_op},
4640							$tracelevel)
4641							}
4642	490					1762	$_[1] = $text;
4643	490					4013	return $return;
4644							}
4645
4646							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
4647							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr_list
4648							{
4649	490			490		1013	my $thisparser = $_[0];
4650	23			23		184	use vars q{$tracelevel};
	23					75
	23					11112
4651	490		50			1922	local $tracelevel = ($tracelevel\|\|0)+1;
4652	490					732	$ERRORS = 0;
4653	490					1601	my $thisrule = $thisparser->{"rules"}{"expr_list"};
4654
4655	490	50				1144	Parse::RecDescent::_trace(q{Trying rule: [expr_list]},
4656							Parse::RecDescent::_tracefirst($_[1]),
4657							q{expr_list},
4658							$tracelevel)
4659							if defined $::RD_TRACE;
4660
4661
4662	490					636	my $err_at = @{$thisparser->{errors}};
	490					1029
4663
4664	490					747	my $score;
4665							my $score_return;
4666	0					0	my $_tok;
4667	490					642	my $return = undef;
4668	490					659	my $_matched=0;
4669	490					708	my $commit=0;
4670	490					845	my @item = ();
4671	490					1717	my %item = ();
4672	490					682	my $repeating = $_[2];
4673	490					688	my $_noactions = $_[3];
4674	490	50				1158	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	490					585
	490					959
4675	490					769	my $_itempos = $_[5];
4676	490	50				1447	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4677	490					784	my $text;
4678							my $lastsep;
4679	0					0	my $current_match;
4680	490					1850	my $expectation = new Parse::RecDescent::Expectation(q{});
4681	490					4055	$expectation->at($_[1]);
4682
4683	490					2137	my $thisline;
4684	490					2420	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4685
4686
4687
4688	490		33			4970	while (!$_matched && !$commit)
4689							{
4690
4691	490	50				1247	Parse::RecDescent::_trace(q{Trying production: []},
4692							Parse::RecDescent::_tracefirst($_[1]),
4693							q{expr_list},
4694							$tracelevel)
4695							if defined $::RD_TRACE;
4696	490					1346	my $thisprod = $thisrule->{"prods"}[0];
4697	490					1001	$text = $_[1];
4698	490					710	my $_savetext;
4699	490					2339	@item = (q{expr_list});
4700	490					1197	%item = (__RULE__ => q{expr_list});
4701	490					752	my $repcount = 0;
4702
4703
4704	490	50				1028	Parse::RecDescent::_trace(q{Trying operator: []},
4705							Parse::RecDescent::_tracefirst($text),
4706							q{expr_list},
4707							$tracelevel)
4708							if defined $::RD_TRACE;
4709	490					1492	$expectation->is(q{})->at($text);
4710
4711	490					3169	$_tok = undef;
4712	490					608	OPLOOP: while (1)
4713							{
4714	490					851	$repcount = 0;
4715	490					761	my @item;
4716							my %item;
4717
4718							# MATCH LEFTARG
4719
4720	490	50				1059	Parse::RecDescent::_trace(q{Trying subrule: [expr]},
4721							Parse::RecDescent::_tracefirst($text),
4722							q{expr_list},
4723							$tracelevel)
4724							if defined $::RD_TRACE;
4725	23			23		162	if (1) { no strict qw{refs};
	23					50
	23					12801
	490					570
4726	490					1415	$expectation->is(q{expr})->at($text);
4727	490	50		490		5537	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	490					1203
4728							{
4729
4730	0	0				0	Parse::RecDescent::_trace(q{<>},
4731							Parse::RecDescent::_tracefirst($text),
4732							q{expr_list},
4733							$tracelevel)
4734							if defined $::RD_TRACE;
4735	0					0	$expectation->failed();
4736	0					0	last;
4737							}
4738	490	50				2524	Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
4739							. $_tok . q{]},
4740
4741							Parse::RecDescent::_tracefirst($text),
4742							q{expr_list},
4743							$tracelevel)
4744							if defined $::RD_TRACE;
4745	490					1205	$item{q{expr}} = $_tok;
4746	490					874	push @item, $_tok;
4747
4748							}
4749
4750
4751
4752	490					748	$repcount++;
4753
4754	490					883	my $savetext = $text;
4755	490					651	my $backtrack;
4756
4757							# MATCH (OP RIGHTARG)(s)
4758	490					1560	while ($repcount < 100000000)
4759							{
4760	792					1169	$backtrack = 0;
4761
4762	792	50				3418	Parse::RecDescent::_trace(q{Trying terminal: [',']},
4763							Parse::RecDescent::_tracefirst($text),
4764							q{expr_list},
4765							$tracelevel)
4766							if defined $::RD_TRACE;
4767	792					1276	undef $lastsep;
4768	792					2867	$expectation->is(q{','})->at($text);
4769
4770
4771	792	50	66			9902	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\,/)
	792	100				8084
4772							{
4773	490	50				1531	$text = $lastsep . $text if defined $lastsep;
4774
4775	490					2235	$expectation->failed();
4776	490	50				4961	Parse::RecDescent::_trace(qq{<>},
4777							Parse::RecDescent::_tracefirst($text))
4778							if defined $::RD_TRACE;
4779	490					865	last;
4780							}
4781	302					1793	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4782	302					1179	substr($text,0,length($current_match),q{});
4783	302	50				839	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4784							. $current_match . q{])},
4785							Parse::RecDescent::_tracefirst($text))
4786							if defined $::RD_TRACE;
4787	302					1027	push @item, $item{__STRING1__}=$current_match;
4788
4789
4790	302					518	pop @item;
4791
4792
4793	302	50				955	Parse::RecDescent::_trace(q{Trying subrule: [expr]},
4794							Parse::RecDescent::_tracefirst($text),
4795							q{expr_list},
4796							$tracelevel)
4797							if defined $::RD_TRACE;
4798	23			23		172	if (1) { no strict qw{refs};
	23					70
	23					134650
	302					394
4799	302					1059	$expectation->is(q{expr})->at($text);
4800	302	50		302		23624	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	302					768
4801							{
4802
4803	0	0				0	Parse::RecDescent::_trace(q{<>},
4804							Parse::RecDescent::_tracefirst($text),
4805							q{expr_list},
4806							$tracelevel)
4807							if defined $::RD_TRACE;
4808	0					0	$expectation->failed();
4809	0					0	last;
4810							}
4811	302	50				1525	Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
4812							. $_tok . q{]},
4813
4814							Parse::RecDescent::_tracefirst($text),
4815							q{expr_list},
4816							$tracelevel)
4817							if defined $::RD_TRACE;
4818	302					745	$item{q{expr}} = $_tok;
4819	302					587	push @item, $_tok;
4820
4821							}
4822
4823	302					579	$savetext = $text;
4824	302					1014	$repcount++;
4825							}
4826	490					917	$text = $savetext;
4827	490	50				1154	pop @item if $backtrack;
4828
4829	490	50				1370	unless (@item) { undef $_tok; last }
	0					0
	0					0
4830	490					1136	$_tok = [ @item ];
4831
4832	490					1311	last;
4833							} # end of OPLOOP
4834
4835	490	50				1290	unless ($repcount>=1)
4836							{
4837	0	0				0	Parse::RecDescent::_trace(q{<]>>},
4838							Parse::RecDescent::_tracefirst($text),
4839							q{expr_list},
4840							$tracelevel)
4841							if defined $::RD_TRACE;
4842	0					0	$expectation->failed();
4843	0					0	last;
4844							}
4845	490	50				1305	Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [}
4846	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
4847							Parse::RecDescent::_tracefirst($text),
4848							q{expr_list},
4849							$tracelevel)
4850							if defined $::RD_TRACE;
4851
4852	490		50			1841	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
4853
4854	490	50				1062	Parse::RecDescent::_trace(q{Trying action},
4855							Parse::RecDescent::_tracefirst($text),
4856							q{expr_list},
4857							$tracelevel)
4858							if defined $::RD_TRACE;
4859
4860
4861	490	50				1111	$_tok = ($_noactions) ? 0 : do {
4862							#warn 'expr_list '
4863							# if $Math::Symbolic::Parser::DEBUG;
4864	490					801	$item[1]
4865							};
4866	490	50				1214	unless (defined $_tok)
4867							{
4868	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
4869							if defined $::RD_TRACE;
4870	0					0	last;
4871							}
4872	490	50				1054	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4873							. $_tok . q{])},
4874							Parse::RecDescent::_tracefirst($text))
4875							if defined $::RD_TRACE;
4876	490					745	push @item, $_tok;
4877	490					920	$item{__ACTION1__}=$_tok;
4878
4879
4880	490	50				1038	Parse::RecDescent::_trace(q{>>Matched production: []<<},
4881							Parse::RecDescent::_tracefirst($text),
4882							q{expr_list},
4883							$tracelevel)
4884							if defined $::RD_TRACE;
4885
4886
4887
4888	490					656	$_matched = 1;
4889	490					904	last;
4890							}
4891
4892
4893	490	50	33			1383	unless ( $_matched \|\| defined($score) )
4894							{
4895
4896
4897	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
4898	0	0				0	Parse::RecDescent::_trace(q{<>},
4899							Parse::RecDescent::_tracefirst($_[1]),
4900							q{expr_list},
4901							$tracelevel)
4902							if defined $::RD_TRACE;
4903	0					0	return undef;
4904							}
4905	490	50	33			2285	if (!defined($return) && defined($score))
4906							{
4907	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4908							q{expr_list},
4909							$tracelevel)
4910							if defined $::RD_TRACE;
4911	0					0	$return = $score_return;
4912							}
4913	490					636	splice @{$thisparser->{errors}}, $err_at;
	490					2196
4914	490	50				1409	$return = $item[$#item] unless defined $return;
4915	490	50				1130	if (defined $::RD_TRACE)
4916							{
4917	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4918							$return . q{])}, "",
4919							q{expr_list},
4920							$tracelevel);
4921	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
4922							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4923							Parse::RecDescent::_tracefirst($text),
4924							, q{expr_list},
4925							$tracelevel)
4926							}
4927	490					1151	$_[1] = $text;
4928	490					4737	return $return;
4929							}
4930							}
4931	24			24	0	25064	package Math::Symbolic::Parser::Precompiled; sub new { my $self = bless( {
4932							'localvars' => '',
4933							'startcode' => '',
4934							'namespace' => 'Parse::RecDescent::Math::Symbolic::Parser::Precompiled',
4935							'rules' => {
4936							'exp' => bless( {
4937							'impcount' => 0,
4938							'calls' => [
4939							'factor'
4940							],
4941							'opcount' => 0,
4942							'prods' => [
4943							bless( {
4944							'number' => 0,
4945							'strcount' => 1,
4946							'dircount' => 1,
4947							'uncommit' => undef,
4948							'error' => undef,
4949							'patcount' => 0,
4950							'actcount' => 1,
4951							'op' => [],
4952							'items' => [
4953							bless( {
4954							'expected' => '',
4955							'min' => 1,
4956							'name' => '',
4957							'max' => 100000000,
4958							'leftarg' => bless( {
4959							'subrule' => 'factor',
4960							'matchrule' => 0,
4961							'implicit' => undef,
4962							'argcode' => undef,
4963							'lookahead' => 0,
4964							'line' => 58
4965							}, 'Parse::RecDescent::Subrule' ),
4966							'rightarg' => bless( {
4967							'subrule' => 'factor',
4968							'matchrule' => 0,
4969							'implicit' => undef,
4970							'argcode' => undef,
4971							'lookahead' => 0,
4972							'line' => 58
4973							}, 'Parse::RecDescent::Subrule' ),
4974							'hashname' => '__DIRECTIVE1__',
4975							'type' => 'rightop',
4976							'op' => bless( {
4977							'pattern' => '^',
4978							'hashname' => '__STRING1__',
4979							'description' => '\'^\'',
4980							'lookahead' => 0,
4981							'line' => 58
4982							}, 'Parse::RecDescent::Literal' )
4983							}, 'Parse::RecDescent::Operator' ),
4984							bless( {
4985							'hashname' => '__ACTION1__',
4986							'lookahead' => 0,
4987							'line' => 59,
4988							'code' => '{
4989							#warn \'exp \' if $Math::Symbolic::Parser::DEBUG;
4990							if (@{$item[1]} == 1) {
4991							$item[1][0]
4992							}
4993							else {
4994							my @it = reverse @{$item[1]};
4995							my $tree = shift @it;
4996							while (@it) {
4997							$tree = Math::Symbolic::Operator->new(
4998							\'^\', shift(@it), $tree
4999							);
5000							}
5001							$tree;
5002							}
5003							}'
5004							}, 'Parse::RecDescent::Action' )
5005							],
5006							'line' => undef
5007							}, 'Parse::RecDescent::Production' )
5008							],
5009							'name' => 'exp',
5010							'vars' => '',
5011							'changed' => 0,
5012							'line' => 58
5013							}, 'Parse::RecDescent::Rule' ),
5014							'variable' => bless( {
5015							'impcount' => 0,
5016							'calls' => [
5017							'identifier_list'
5018							],
5019							'opcount' => 0,
5020							'prods' => [
5021							bless( {
5022							'number' => 0,
5023							'strcount' => 2,
5024							'dircount' => 0,
5025							'uncommit' => undef,
5026							'error' => undef,
5027							'patcount' => 2,
5028							'actcount' => 1,
5029							'items' => [
5030							bless( {
5031							'description' => '/[a-zA-Z][a-zA-Z0-9_]*/',
5032							'rdelim' => '/',
5033							'pattern' => '[a-zA-Z][a-zA-Z0-9_]*',
5034							'hashname' => '__PATTERN1__',
5035							'lookahead' => 0,
5036							'ldelim' => '/',
5037							'mod' => '',
5038							'line' => 200
5039							}, 'Parse::RecDescent::Token' ),
5040							bless( {
5041							'description' => '/\\\\\'*/',
5042							'rdelim' => '/',
5043							'pattern' => '\\\'*',
5044							'hashname' => '__PATTERN2__',
5045							'lookahead' => 0,
5046							'ldelim' => '/',
5047							'mod' => '',
5048							'line' => 200
5049							}, 'Parse::RecDescent::Token' ),
5050							bless( {
5051							'pattern' => '(',
5052							'hashname' => '__STRING1__',
5053							'description' => '\'(\'',
5054							'lookahead' => 0,
5055							'line' => 200
5056							}, 'Parse::RecDescent::Literal' ),
5057							bless( {
5058							'subrule' => 'identifier_list',
5059							'matchrule' => 0,
5060							'implicit' => undef,
5061							'argcode' => undef,
5062							'lookahead' => 0,
5063							'line' => 200
5064							}, 'Parse::RecDescent::Subrule' ),
5065							bless( {
5066							'pattern' => ')',
5067							'hashname' => '__STRING2__',
5068							'description' => '\')\'',
5069							'lookahead' => 0,
5070							'line' => 200
5071							}, 'Parse::RecDescent::Literal' ),
5072							bless( {
5073							'hashname' => '__ACTION1__',
5074							'lookahead' => 0,
5075							'line' => 201,
5076							'code' => '{
5077							#warn \'variable \'
5078							# if $Math::Symbolic::Parser::DEBUG;
5079							my $varname = $item[1];
5080							my $ticks = $item[2];
5081							if ($ticks) {
5082							my $n = length($ticks);
5083							my $sig = $item[4] \|\| [\'x\'];
5084							my $dep_var = $sig->[0];
5085							my $return = Math::Symbolic::Variable->new(
5086							{ name => $varname, signature => $sig }
5087							);
5088							foreach (1..$n) {
5089							$return = Math::Symbolic::Operator->new(
5090							\'partial_derivative\',
5091							$return, $dep_var,
5092							);
5093							}
5094							$return;
5095							}
5096							else {
5097							Math::Symbolic::Variable->new(
5098							{ name => $varname, signature => $item[4] }
5099							);
5100							}
5101							}'
5102							}, 'Parse::RecDescent::Action' )
5103							],
5104							'line' => undef
5105							}, 'Parse::RecDescent::Production' ),
5106							bless( {
5107							'number' => 1,
5108							'strcount' => 0,
5109							'dircount' => 0,
5110							'uncommit' => undef,
5111							'error' => undef,
5112							'patcount' => 2,
5113							'actcount' => 1,
5114							'items' => [
5115							bless( {
5116							'description' => '/[a-zA-Z][a-zA-Z0-9_]*/',
5117							'rdelim' => '/',
5118							'pattern' => '[a-zA-Z][a-zA-Z0-9_]*',
5119							'hashname' => '__PATTERN1__',
5120							'lookahead' => 0,
5121							'ldelim' => '/',
5122							'mod' => '',
5123							'line' => 228
5124							}, 'Parse::RecDescent::Token' ),
5125							bless( {
5126							'description' => '/\\\\\'*/',
5127							'rdelim' => '/',
5128							'pattern' => '\\\'*',
5129							'hashname' => '__PATTERN2__',
5130							'lookahead' => 0,
5131							'ldelim' => '/',
5132							'mod' => '',
5133							'line' => 228
5134							}, 'Parse::RecDescent::Token' ),
5135							bless( {
5136							'hashname' => '__ACTION1__',
5137							'lookahead' => 0,
5138							'line' => 229,
5139							'code' => '{
5140							#warn \'variable \'
5141							# if $Math::Symbolic::Parser::DEBUG;
5142							my $varname = $item[1];
5143							my $ticks = $item[2];
5144							if ($ticks) {
5145							my $n = length($ticks);
5146							my $return = Math::Symbolic::Variable->new(
5147							{ name => $varname, signature => [\'x\'] }
5148							);
5149							foreach (1..$n) {
5150							$return = Math::Symbolic::Operator->new(
5151							\'partial_derivative\',
5152							$return, \'x\',
5153							);
5154							}
5155							$return;
5156							}
5157							else {
5158							Math::Symbolic::Variable->new( $varname );
5159							}
5160							}'
5161							}, 'Parse::RecDescent::Action' )
5162							],
5163							'line' => 228
5164							}, 'Parse::RecDescent::Production' )
5165							],
5166							'name' => 'variable',
5167							'vars' => '',
5168							'changed' => 0,
5169							'line' => 200
5170							}, 'Parse::RecDescent::Rule' ),
5171							'function' => bless( {
5172							'impcount' => 0,
5173							'calls' => [
5174							'function_name',
5175							'expr_list'
5176							],
5177							'opcount' => 0,
5178							'prods' => [
5179							bless( {
5180							'number' => 0,
5181							'strcount' => 2,
5182							'dircount' => 0,
5183							'uncommit' => undef,
5184							'error' => undef,
5185							'patcount' => 0,
5186							'actcount' => 1,
5187							'items' => [
5188							bless( {
5189							'subrule' => 'function_name',
5190							'matchrule' => 0,
5191							'implicit' => undef,
5192							'argcode' => undef,
5193							'lookahead' => 0,
5194							'line' => 151
5195							}, 'Parse::RecDescent::Subrule' ),
5196							bless( {
5197							'pattern' => '(',
5198							'hashname' => '__STRING1__',
5199							'description' => '\'(\'',
5200							'lookahead' => 0,
5201							'line' => 151
5202							}, 'Parse::RecDescent::Literal' ),
5203							bless( {
5204							'subrule' => 'expr_list',
5205							'matchrule' => 0,
5206							'implicit' => undef,
5207							'argcode' => undef,
5208							'lookahead' => 0,
5209							'line' => 151
5210							}, 'Parse::RecDescent::Subrule' ),
5211							bless( {
5212							'pattern' => ')',
5213							'hashname' => '__STRING2__',
5214							'description' => '\')\'',
5215							'lookahead' => 0,
5216							'line' => 151
5217							}, 'Parse::RecDescent::Literal' ),
5218							bless( {
5219							'hashname' => '__ACTION1__',
5220							'lookahead' => 0,
5221							'line' => 152,
5222							'code' => '{
5223							#warn \'function \'
5224							# if $Math::Symbolic::Parser::DEBUG;
5225							my $fname = $item[1];
5226							my $function;
5227							if (exists($Math::Symbolic::Parser::Parser_Functions{$fname})) {
5228							$function = $Math::Symbolic::Parser::Parser_Functions{$fname}->($fname, @{$item[3]});
5229							die "Invalid function \'$fname\'!"
5230							unless defined $function;
5231							}
5232							else {
5233							$function = $Math::Symbolic::Operator::Op_Symbols{ $fname };
5234							die "Invalid function \'$fname\'!"
5235							unless defined $function;
5236							$function = Math::Symbolic::Operator->new(
5237							{ type => $function, operands => $item[3] }
5238							);
5239							}
5240							$function
5241							}'
5242							}, 'Parse::RecDescent::Action' )
5243							],
5244							'line' => undef
5245							}, 'Parse::RecDescent::Production' )
5246							],
5247							'name' => 'function',
5248							'vars' => '',
5249							'changed' => 0,
5250							'line' => 151
5251							}, 'Parse::RecDescent::Rule' ),
5252							'number' => bless( {
5253							'impcount' => 0,
5254							'calls' => [],
5255							'opcount' => 0,
5256							'prods' => [
5257							bless( {
5258							'number' => 0,
5259							'strcount' => 0,
5260							'dircount' => 0,
5261							'uncommit' => undef,
5262							'error' => undef,
5263							'patcount' => 1,
5264							'actcount' => 1,
5265							'items' => [
5266							bless( {
5267							'description' => '/([+-]?)(?=\\\\d\|\\\\.\\\\d)\\\\d(\\\\.\\\\d)?([Ee]([+-]?\\\\d+))?/',
5268							'rdelim' => '/',
5269							'pattern' => '([+-]?)(?=\\d\|\\.\\d)\\d(\\.\\d)?([Ee]([+-]?\\d+))?',
5270							'hashname' => '__PATTERN1__',
5271							'lookahead' => 0,
5272							'ldelim' => '/',
5273							'mod' => '',
5274							'line' => 144
5275							}, 'Parse::RecDescent::Token' ),
5276							bless( {
5277							'hashname' => '__ACTION1__',
5278							'lookahead' => 0,
5279							'line' => 145,
5280							'code' => '{
5281							#warn \'number \'
5282							# if $Math::Symbolic::Parser::DEBUG;
5283							Math::Symbolic::Constant->new($item[1])
5284							}'
5285							}, 'Parse::RecDescent::Action' )
5286							],
5287							'line' => undef
5288							}, 'Parse::RecDescent::Production' )
5289							],
5290							'name' => 'number',
5291							'vars' => '',
5292							'changed' => 0,
5293							'line' => 144
5294							}, 'Parse::RecDescent::Rule' ),
5295							'multiplication' => bless( {
5296							'impcount' => 0,
5297							'calls' => [
5298							'exp',
5299							'mult_op'
5300							],
5301							'opcount' => 0,
5302							'prods' => [
5303							bless( {
5304							'number' => 0,
5305							'strcount' => 0,
5306							'dircount' => 1,
5307							'uncommit' => undef,
5308							'error' => undef,
5309							'patcount' => 0,
5310							'actcount' => 1,
5311							'op' => [],
5312							'items' => [
5313							bless( {
5314							'expected' => '',
5315							'min' => 1,
5316							'name' => '',
5317							'max' => 100000000,
5318							'leftarg' => bless( {
5319							'subrule' => 'exp',
5320							'matchrule' => 0,
5321							'implicit' => undef,
5322							'argcode' => undef,
5323							'lookahead' => 0,
5324							'line' => 35
5325							}, 'Parse::RecDescent::Subrule' ),
5326							'rightarg' => bless( {
5327							'subrule' => 'exp',
5328							'matchrule' => 0,
5329							'implicit' => undef,
5330							'argcode' => undef,
5331							'lookahead' => 0,
5332							'line' => 35
5333							}, 'Parse::RecDescent::Subrule' ),
5334							'hashname' => '__DIRECTIVE1__',
5335							'type' => 'leftop',
5336							'op' => bless( {
5337							'subrule' => 'mult_op',
5338							'matchrule' => 0,
5339							'implicit' => undef,
5340							'argcode' => undef,
5341							'lookahead' => 0,
5342							'line' => 35
5343							}, 'Parse::RecDescent::Subrule' )
5344							}, 'Parse::RecDescent::Operator' ),
5345							bless( {
5346							'hashname' => '__ACTION1__',
5347							'lookahead' => 0,
5348							'line' => 36,
5349							'code' => '{
5350							#warn \'multiplication \'
5351							# if $Math::Symbolic::Parser::DEBUG;
5352							if (@{$item[1]} == 1) {
5353							$item[1][0]
5354							}
5355							else {
5356							my @it = @{$item[1]};
5357							my $tree = shift @it;
5358							while (@it) {
5359							$tree = Math::Symbolic::Operator->new(
5360							shift(@it), $tree, shift(@it)
5361							);
5362							}
5363							$tree;
5364							}
5365							}'
5366							}, 'Parse::RecDescent::Action' )
5367							],
5368							'line' => undef
5369							}, 'Parse::RecDescent::Production' )
5370							],
5371							'name' => 'multiplication',
5372							'vars' => '',
5373							'changed' => 0,
5374							'line' => 35
5375							}, 'Parse::RecDescent::Rule' ),
5376							'parse' => bless( {
5377							'impcount' => 0,
5378							'calls' => [
5379							'expr'
5380							],
5381							'opcount' => 0,
5382							'prods' => [
5383							bless( {
5384							'number' => 0,
5385							'strcount' => 0,
5386							'dircount' => 0,
5387							'uncommit' => undef,
5388							'error' => undef,
5389							'patcount' => 1,
5390							'actcount' => 1,
5391							'items' => [
5392							bless( {
5393							'subrule' => 'expr',
5394							'matchrule' => 0,
5395							'implicit' => undef,
5396							'argcode' => undef,
5397							'lookahead' => 0,
5398							'line' => 1
5399							}, 'Parse::RecDescent::Subrule' ),
5400							bless( {
5401							'description' => '/^\\\\Z/',
5402							'rdelim' => '/',
5403							'pattern' => '^\\Z',
5404							'hashname' => '__PATTERN1__',
5405							'lookahead' => 0,
5406							'ldelim' => '/',
5407							'mod' => '',
5408							'line' => 1
5409							}, 'Parse::RecDescent::Token' ),
5410							bless( {
5411							'hashname' => '__ACTION1__',
5412							'lookahead' => 0,
5413							'line' => 2,
5414							'code' => '{
5415							$return = $item[1]
5416							}'
5417							}, 'Parse::RecDescent::Action' )
5418							],
5419							'line' => undef
5420							}, 'Parse::RecDescent::Production' ),
5421							bless( {
5422							'number' => 1,
5423							'strcount' => 0,
5424							'dircount' => 0,
5425							'uncommit' => undef,
5426							'error' => undef,
5427							'patcount' => 1,
5428							'actcount' => 1,
5429							'items' => [
5430							bless( {
5431							'description' => '//',
5432							'rdelim' => '/',
5433							'pattern' => '',
5434							'hashname' => '__PATTERN1__',
5435							'lookahead' => 0,
5436							'ldelim' => '/',
5437							'mod' => '',
5438							'line' => 5
5439							}, 'Parse::RecDescent::Token' ),
5440							bless( {
5441							'hashname' => '__ACTION1__',
5442							'lookahead' => 0,
5443							'line' => 5,
5444							'code' => '{undef}'
5445							}, 'Parse::RecDescent::Action' )
5446							],
5447							'line' => 5
5448							}, 'Parse::RecDescent::Production' )
5449							],
5450							'name' => 'parse',
5451							'vars' => '',
5452							'changed' => 0,
5453							'line' => 1
5454							}, 'Parse::RecDescent::Rule' ),
5455							'addition' => bless( {
5456							'impcount' => 0,
5457							'calls' => [
5458							'multiplication',
5459							'add_op'
5460							],
5461							'opcount' => 0,
5462							'prods' => [
5463							bless( {
5464							'number' => 0,
5465							'strcount' => 0,
5466							'dircount' => 1,
5467							'uncommit' => undef,
5468							'error' => undef,
5469							'patcount' => 0,
5470							'actcount' => 1,
5471							'op' => [],
5472							'items' => [
5473							bless( {
5474							'expected' => '',
5475							'min' => 1,
5476							'name' => '',
5477							'max' => 100000000,
5478							'leftarg' => bless( {
5479							'subrule' => 'multiplication',
5480							'matchrule' => 0,
5481							'implicit' => undef,
5482							'argcode' => undef,
5483							'lookahead' => 0,
5484							'line' => 13
5485							}, 'Parse::RecDescent::Subrule' ),
5486							'rightarg' => bless( {
5487							'subrule' => 'multiplication',
5488							'matchrule' => 0,
5489							'implicit' => undef,
5490							'argcode' => undef,
5491							'lookahead' => 0,
5492							'line' => 13
5493							}, 'Parse::RecDescent::Subrule' ),
5494							'hashname' => '__DIRECTIVE1__',
5495							'type' => 'leftop',
5496							'op' => bless( {
5497							'subrule' => 'add_op',
5498							'matchrule' => 0,
5499							'implicit' => undef,
5500							'argcode' => undef,
5501							'lookahead' => 0,
5502							'line' => 13
5503							}, 'Parse::RecDescent::Subrule' )
5504							}, 'Parse::RecDescent::Operator' ),
5505							bless( {
5506							'hashname' => '__ACTION1__',
5507							'lookahead' => 0,
5508							'line' => 14,
5509							'code' => '{
5510							#warn \'addition \'
5511							# if $Math::Symbolic::Parser::DEBUG;
5512							if (@{$item[1]} == 1) {
5513							$item[1][0]
5514							}
5515							else {
5516							my @it = @{$item[1]};
5517							my $tree = shift @it;
5518							while (@it) {
5519							$tree = Math::Symbolic::Operator->new(
5520							shift(@it), $tree, shift(@it)
5521							);
5522							}
5523							$tree;
5524							}
5525							}'
5526							}, 'Parse::RecDescent::Action' )
5527							],
5528							'line' => undef
5529							}, 'Parse::RecDescent::Production' )
5530							],
5531							'name' => 'addition',
5532							'vars' => '',
5533							'changed' => 0,
5534							'line' => 13
5535							}, 'Parse::RecDescent::Rule' ),
5536							'factor' => bless( {
5537							'impcount' => 0,
5538							'calls' => [
5539							'number',
5540							'function',
5541							'variable',
5542							'expr'
5543							],
5544							'opcount' => 0,
5545							'prods' => [
5546							bless( {
5547							'number' => 0,
5548							'strcount' => 0,
5549							'dircount' => 0,
5550							'uncommit' => undef,
5551							'error' => undef,
5552							'patcount' => 1,
5553							'actcount' => 1,
5554							'items' => [
5555							bless( {
5556							'description' => '/(?:\\\\+\|-)*/',
5557							'rdelim' => '/',
5558							'pattern' => '(?:\\+\|-)*',
5559							'hashname' => '__PATTERN1__',
5560							'lookahead' => 0,
5561							'ldelim' => '/',
5562							'mod' => '',
5563							'line' => 76
5564							}, 'Parse::RecDescent::Token' ),
5565							bless( {
5566							'subrule' => 'number',
5567							'matchrule' => 0,
5568							'implicit' => undef,
5569							'argcode' => undef,
5570							'lookahead' => 0,
5571							'line' => 76
5572							}, 'Parse::RecDescent::Subrule' ),
5573							bless( {
5574							'hashname' => '__ACTION1__',
5575							'lookahead' => 0,
5576							'line' => 77,
5577							'code' => '{
5578							#warn \'unary_n \'
5579							# if $Math::Symbolic::Parser::DEBUG;
5580							if ($item[1]) {
5581							my @it = split //, $item[1];
5582							my $ret = $item[2];
5583							foreach (grep {$_ eq \'-\'} @it) {
5584							$ret = Math::Symbolic::Operator->new(\'neg\',$ret);
5585							}
5586							$ret
5587							}
5588							else {
5589							$item[2]
5590							}
5591							}'
5592							}, 'Parse::RecDescent::Action' )
5593							],
5594							'line' => undef
5595							}, 'Parse::RecDescent::Production' ),
5596							bless( {
5597							'number' => 1,
5598							'strcount' => 0,
5599							'dircount' => 0,
5600							'uncommit' => undef,
5601							'error' => undef,
5602							'patcount' => 1,
5603							'actcount' => 1,
5604							'items' => [
5605							bless( {
5606							'description' => '/(?:\\\\+\|-)*/',
5607							'rdelim' => '/',
5608							'pattern' => '(?:\\+\|-)*',
5609							'hashname' => '__PATTERN1__',
5610							'lookahead' => 0,
5611							'ldelim' => '/',
5612							'mod' => '',
5613							'line' => 93
5614							}, 'Parse::RecDescent::Token' ),
5615							bless( {
5616							'subrule' => 'function',
5617							'matchrule' => 0,
5618							'implicit' => undef,
5619							'argcode' => undef,
5620							'lookahead' => 0,
5621							'line' => 93
5622							}, 'Parse::RecDescent::Subrule' ),
5623							bless( {
5624							'hashname' => '__ACTION1__',
5625							'lookahead' => 0,
5626							'line' => 94,
5627							'code' => '{
5628							#warn \'unary_f \'
5629							# if $Math::Symbolic::Parser::DEBUG;
5630							if ($item[1]) {
5631							my @it = split //, $item[1];
5632							my $ret = $item[2];
5633							foreach (grep {$_ eq \'-\'} @it) {
5634							$ret = Math::Symbolic::Operator->new(\'neg\',$ret);
5635							}
5636							$ret
5637							}
5638							else {
5639							$item[2]
5640							}
5641							}'
5642							}, 'Parse::RecDescent::Action' )
5643							],
5644							'line' => 93
5645							}, 'Parse::RecDescent::Production' ),
5646							bless( {
5647							'number' => 2,
5648							'strcount' => 0,
5649							'dircount' => 0,
5650							'uncommit' => undef,
5651							'error' => undef,
5652							'patcount' => 1,
5653							'actcount' => 1,
5654							'items' => [
5655							bless( {
5656							'description' => '/(?:\\\\+\|-)*/',
5657							'rdelim' => '/',
5658							'pattern' => '(?:\\+\|-)*',
5659							'hashname' => '__PATTERN1__',
5660							'lookahead' => 0,
5661							'ldelim' => '/',
5662							'mod' => '',
5663							'line' => 110
5664							}, 'Parse::RecDescent::Token' ),
5665							bless( {
5666							'subrule' => 'variable',
5667							'matchrule' => 0,
5668							'implicit' => undef,
5669							'argcode' => undef,
5670							'lookahead' => 0,
5671							'line' => 110
5672							}, 'Parse::RecDescent::Subrule' ),
5673							bless( {
5674							'hashname' => '__ACTION1__',
5675							'lookahead' => 0,
5676							'line' => 111,
5677							'code' => '{
5678							#warn \'unary_v \'
5679							# if $Math::Symbolic::Parser::DEBUG;
5680							if ($item[1]) {
5681							my @it = split //, $item[1];
5682							my $ret = $item[2];
5683							foreach (grep {$_ eq \'-\'} @it) {
5684							$ret = Math::Symbolic::Operator->new(\'neg\',$ret);
5685							}
5686							$ret
5687							}
5688							else {
5689							$item[2]
5690							}
5691							}'
5692							}, 'Parse::RecDescent::Action' )
5693							],
5694							'line' => 110
5695							}, 'Parse::RecDescent::Production' ),
5696							bless( {
5697							'number' => 3,
5698							'strcount' => 2,
5699							'dircount' => 0,
5700							'uncommit' => undef,
5701							'error' => undef,
5702							'patcount' => 1,
5703							'actcount' => 1,
5704							'items' => [
5705							bless( {
5706							'description' => '/(?:\\\\+\|-)*/',
5707							'rdelim' => '/',
5708							'pattern' => '(?:\\+\|-)*',
5709							'hashname' => '__PATTERN1__',
5710							'lookahead' => 0,
5711							'ldelim' => '/',
5712							'mod' => '',
5713							'line' => 127
5714							}, 'Parse::RecDescent::Token' ),
5715							bless( {
5716							'pattern' => '(',
5717							'hashname' => '__STRING1__',
5718							'description' => '\'(\'',
5719							'lookahead' => 0,
5720							'line' => 127
5721							}, 'Parse::RecDescent::Literal' ),
5722							bless( {
5723							'subrule' => 'expr',
5724							'matchrule' => 0,
5725							'implicit' => undef,
5726							'argcode' => undef,
5727							'lookahead' => 0,
5728							'line' => 127
5729							}, 'Parse::RecDescent::Subrule' ),
5730							bless( {
5731							'pattern' => ')',
5732							'hashname' => '__STRING2__',
5733							'description' => '\')\'',
5734							'lookahead' => 0,
5735							'line' => 127
5736							}, 'Parse::RecDescent::Literal' ),
5737							bless( {
5738							'hashname' => '__ACTION1__',
5739							'lookahead' => 0,
5740							'line' => 128,
5741							'code' => '{
5742							#warn \'unary_expr \'
5743							# if $Math::Symbolic::Parser::DEBUG;
5744							if ($item[1]) {
5745							my @it = split //, $item[1];
5746							my $ret = $item[3];
5747							foreach (grep {$_ eq \'-\'} @it) {
5748							$ret = Math::Symbolic::Operator->new(\'neg\',$ret);
5749							}
5750							$ret
5751							}
5752							else {
5753							$item[3]
5754							}
5755							}'
5756							}, 'Parse::RecDescent::Action' )
5757							],
5758							'line' => 127
5759							}, 'Parse::RecDescent::Production' )
5760							],
5761							'name' => 'factor',
5762							'vars' => '',
5763							'changed' => 0,
5764							'line' => 76
5765							}, 'Parse::RecDescent::Rule' ),
5766							'identifier_list' => bless( {
5767							'impcount' => 0,
5768							'calls' => [],
5769							'opcount' => 0,
5770							'prods' => [
5771							bless( {
5772							'number' => 0,
5773							'strcount' => 1,
5774							'dircount' => 1,
5775							'uncommit' => undef,
5776							'error' => undef,
5777							'patcount' => 2,
5778							'actcount' => 1,
5779							'op' => [],
5780							'items' => [
5781							bless( {
5782							'expected' => '',
5783							'min' => 1,
5784							'name' => '',
5785							'max' => 100000000,
5786							'leftarg' => bless( {
5787							'description' => '/[a-zA-Z][a-zA-Z0-9_]*/',
5788							'rdelim' => '/',
5789							'pattern' => '[a-zA-Z][a-zA-Z0-9_]*',
5790							'hashname' => '__PATTERN1__',
5791							'lookahead' => 0,
5792							'ldelim' => '/',
5793							'mod' => '',
5794							'line' => 252
5795							}, 'Parse::RecDescent::Token' ),
5796							'rightarg' => bless( {
5797							'description' => '/[a-zA-Z][a-zA-Z0-9_]*/',
5798							'rdelim' => '/',
5799							'pattern' => '[a-zA-Z][a-zA-Z0-9_]*',
5800							'hashname' => '__PATTERN2__',
5801							'lookahead' => 0,
5802							'ldelim' => '/',
5803							'mod' => '',
5804							'line' => 252
5805							}, 'Parse::RecDescent::Token' ),
5806							'hashname' => '__DIRECTIVE1__',
5807							'type' => 'leftop',
5808							'op' => bless( {
5809							'pattern' => ',',
5810							'hashname' => '__STRING1__',
5811							'description' => '\',\'',
5812							'lookahead' => 0,
5813							'line' => 252
5814							}, 'Parse::RecDescent::Literal' )
5815							}, 'Parse::RecDescent::Operator' ),
5816							bless( {
5817							'hashname' => '__ACTION1__',
5818							'lookahead' => 0,
5819							'line' => 253,
5820							'code' => '{
5821							#warn \'identifier_list \'
5822							# if $Math::Symbolic::Parser::DEBUG;
5823							$item[1]
5824							}'
5825							}, 'Parse::RecDescent::Action' )
5826							],
5827							'line' => undef
5828							}, 'Parse::RecDescent::Production' )
5829							],
5830							'name' => 'identifier_list',
5831							'vars' => '',
5832							'changed' => 0,
5833							'line' => 252
5834							}, 'Parse::RecDescent::Rule' ),
5835							'expr' => bless( {
5836							'impcount' => 0,
5837							'calls' => [
5838							'addition'
5839							],
5840							'opcount' => 0,
5841							'prods' => [
5842							bless( {
5843							'number' => 0,
5844							'strcount' => 0,
5845							'dircount' => 0,
5846							'uncommit' => undef,
5847							'error' => undef,
5848							'patcount' => 0,
5849							'actcount' => 1,
5850							'items' => [
5851							bless( {
5852							'subrule' => 'addition',
5853							'matchrule' => 0,
5854							'implicit' => undef,
5855							'argcode' => undef,
5856							'lookahead' => 0,
5857							'line' => 7
5858							}, 'Parse::RecDescent::Subrule' ),
5859							bless( {
5860							'hashname' => '__ACTION1__',
5861							'lookahead' => 0,
5862							'line' => 8,
5863							'code' => '{
5864							#warn \'expr \' if $Math::Symbolic::Parser::DEBUG;
5865							$item[1]
5866							}'
5867							}, 'Parse::RecDescent::Action' )
5868							],
5869							'line' => undef
5870							}, 'Parse::RecDescent::Production' )
5871							],
5872							'name' => 'expr',
5873							'vars' => '',
5874							'changed' => 0,
5875							'line' => 7
5876							}, 'Parse::RecDescent::Rule' ),
5877							'mult_op' => bless( {
5878							'impcount' => 0,
5879							'calls' => [],
5880							'opcount' => 0,
5881							'prods' => [
5882							bless( {
5883							'number' => 0,
5884							'strcount' => 1,
5885							'dircount' => 0,
5886							'uncommit' => undef,
5887							'error' => undef,
5888							'patcount' => 0,
5889							'actcount' => 0,
5890							'items' => [
5891							bless( {
5892							'pattern' => '*',
5893							'hashname' => '__STRING1__',
5894							'description' => '\'*\'',
5895							'lookahead' => 0,
5896							'line' => 54
5897							}, 'Parse::RecDescent::Literal' )
5898							],
5899							'line' => undef
5900							}, 'Parse::RecDescent::Production' ),
5901							bless( {
5902							'number' => 1,
5903							'strcount' => 1,
5904							'dircount' => 0,
5905							'uncommit' => undef,
5906							'error' => undef,
5907							'patcount' => 0,
5908							'actcount' => 0,
5909							'items' => [
5910							bless( {
5911							'pattern' => '/',
5912							'hashname' => '__STRING1__',
5913							'description' => '\'/\'',
5914							'lookahead' => 0,
5915							'line' => 55
5916							}, 'Parse::RecDescent::Literal' )
5917							],
5918							'line' => 55
5919							}, 'Parse::RecDescent::Production' )
5920							],
5921							'name' => 'mult_op',
5922							'vars' => '',
5923							'changed' => 0,
5924							'line' => 54
5925							}, 'Parse::RecDescent::Rule' ),
5926							'function_name' => bless( {
5927							'impcount' => 0,
5928							'calls' => [],
5929							'opcount' => 0,
5930							'prods' => [
5931							bless( {
5932							'number' => 0,
5933							'strcount' => 1,
5934							'dircount' => 0,
5935							'uncommit' => undef,
5936							'error' => undef,
5937							'patcount' => 0,
5938							'actcount' => 0,
5939							'items' => [
5940							bless( {
5941							'pattern' => 'log',
5942							'hashname' => '__STRING1__',
5943							'description' => '\'log\'',
5944							'lookahead' => 0,
5945							'line' => 173
5946							}, 'Parse::RecDescent::Literal' )
5947							],
5948							'line' => undef
5949							}, 'Parse::RecDescent::Production' ),
5950							bless( {
5951							'number' => 1,
5952							'strcount' => 1,
5953							'dircount' => 0,
5954							'uncommit' => undef,
5955							'error' => undef,
5956							'patcount' => 0,
5957							'actcount' => 0,
5958							'items' => [
5959							bless( {
5960							'pattern' => 'partial_derivative',
5961							'hashname' => '__STRING1__',
5962							'description' => '\'partial_derivative\'',
5963							'lookahead' => 0,
5964							'line' => 174
5965							}, 'Parse::RecDescent::Literal' )
5966							],
5967							'line' => 174
5968							}, 'Parse::RecDescent::Production' ),
5969							bless( {
5970							'number' => 2,
5971							'strcount' => 1,
5972							'dircount' => 0,
5973							'uncommit' => undef,
5974							'error' => undef,
5975							'patcount' => 0,
5976							'actcount' => 0,
5977							'items' => [
5978							bless( {
5979							'pattern' => 'total_derivative',
5980							'hashname' => '__STRING1__',
5981							'description' => '\'total_derivative\'',
5982							'lookahead' => 0,
5983							'line' => 175
5984							}, 'Parse::RecDescent::Literal' )
5985							],
5986							'line' => 175
5987							}, 'Parse::RecDescent::Production' ),
5988							bless( {
5989							'number' => 3,
5990							'strcount' => 1,
5991							'dircount' => 0,
5992							'uncommit' => undef,
5993							'error' => undef,
5994							'patcount' => 0,
5995							'actcount' => 0,
5996							'items' => [
5997							bless( {
5998							'pattern' => 'sinh',
5999							'hashname' => '__STRING1__',
6000							'description' => '\'sinh\'',
6001							'lookahead' => 0,
6002							'line' => 176
6003							}, 'Parse::RecDescent::Literal' )
6004							],
6005							'line' => 176
6006							}, 'Parse::RecDescent::Production' ),
6007							bless( {
6008							'number' => 4,
6009							'strcount' => 1,
6010							'dircount' => 0,
6011							'uncommit' => undef,
6012							'error' => undef,
6013							'patcount' => 0,
6014							'actcount' => 0,
6015							'items' => [
6016							bless( {
6017							'pattern' => 'cosh',
6018							'hashname' => '__STRING1__',
6019							'description' => '\'cosh\'',
6020							'lookahead' => 0,
6021							'line' => 177
6022							}, 'Parse::RecDescent::Literal' )
6023							],
6024							'line' => 177
6025							}, 'Parse::RecDescent::Production' ),
6026							bless( {
6027							'number' => 5,
6028							'strcount' => 1,
6029							'dircount' => 0,
6030							'uncommit' => undef,
6031							'error' => undef,
6032							'patcount' => 0,
6033							'actcount' => 0,
6034							'items' => [
6035							bless( {
6036							'pattern' => 'asinh',
6037							'hashname' => '__STRING1__',
6038							'description' => '\'asinh\'',
6039							'lookahead' => 0,
6040							'line' => 178
6041							}, 'Parse::RecDescent::Literal' )
6042							],
6043							'line' => 178
6044							}, 'Parse::RecDescent::Production' ),
6045							bless( {
6046							'number' => 6,
6047							'strcount' => 1,
6048							'dircount' => 0,
6049							'uncommit' => undef,
6050							'error' => undef,
6051							'patcount' => 0,
6052							'actcount' => 0,
6053							'items' => [
6054							bless( {
6055							'pattern' => 'acosh',
6056							'hashname' => '__STRING1__',
6057							'description' => '\'acosh\'',
6058							'lookahead' => 0,
6059							'line' => 179
6060							}, 'Parse::RecDescent::Literal' )
6061							],
6062							'line' => 179
6063							}, 'Parse::RecDescent::Production' ),
6064							bless( {
6065							'number' => 7,
6066							'strcount' => 1,
6067							'dircount' => 0,
6068							'uncommit' => undef,
6069							'error' => undef,
6070							'patcount' => 0,
6071							'actcount' => 0,
6072							'items' => [
6073							bless( {
6074							'pattern' => 'asin',
6075							'hashname' => '__STRING1__',
6076							'description' => '\'asin\'',
6077							'lookahead' => 0,
6078							'line' => 180
6079							}, 'Parse::RecDescent::Literal' )
6080							],
6081							'line' => 180
6082							}, 'Parse::RecDescent::Production' ),
6083							bless( {
6084							'number' => 8,
6085							'strcount' => 1,
6086							'dircount' => 0,
6087							'uncommit' => undef,
6088							'error' => undef,
6089							'patcount' => 0,
6090							'actcount' => 0,
6091							'items' => [
6092							bless( {
6093							'pattern' => 'acos',
6094							'hashname' => '__STRING1__',
6095							'description' => '\'acos\'',
6096							'lookahead' => 0,
6097							'line' => 181
6098							}, 'Parse::RecDescent::Literal' )
6099							],
6100							'line' => 181
6101							}, 'Parse::RecDescent::Production' ),
6102							bless( {
6103							'number' => 9,
6104							'strcount' => 1,
6105							'dircount' => 0,
6106							'uncommit' => undef,
6107							'error' => undef,
6108							'patcount' => 0,
6109							'actcount' => 0,
6110							'items' => [
6111							bless( {
6112							'pattern' => 'atan2',
6113							'hashname' => '__STRING1__',
6114							'description' => '\'atan2\'',
6115							'lookahead' => 0,
6116							'line' => 182
6117							}, 'Parse::RecDescent::Literal' )
6118							],
6119							'line' => 182
6120							}, 'Parse::RecDescent::Production' ),
6121							bless( {
6122							'number' => 10,
6123							'strcount' => 1,
6124							'dircount' => 0,
6125							'uncommit' => undef,
6126							'error' => undef,
6127							'patcount' => 0,
6128							'actcount' => 0,
6129							'items' => [
6130							bless( {
6131							'pattern' => 'atan',
6132							'hashname' => '__STRING1__',
6133							'description' => '\'atan\'',
6134							'lookahead' => 0,
6135							'line' => 183
6136							}, 'Parse::RecDescent::Literal' )
6137							],
6138							'line' => 183
6139							}, 'Parse::RecDescent::Production' ),
6140							bless( {
6141							'number' => 11,
6142							'strcount' => 1,
6143							'dircount' => 0,
6144							'uncommit' => undef,
6145							'error' => undef,
6146							'patcount' => 0,
6147							'actcount' => 0,
6148							'items' => [
6149							bless( {
6150							'pattern' => 'acot',
6151							'hashname' => '__STRING1__',
6152							'description' => '\'acot\'',
6153							'lookahead' => 0,
6154							'line' => 184
6155							}, 'Parse::RecDescent::Literal' )
6156							],
6157							'line' => 184
6158							}, 'Parse::RecDescent::Production' ),
6159							bless( {
6160							'number' => 12,
6161							'strcount' => 1,
6162							'dircount' => 0,
6163							'uncommit' => undef,
6164							'error' => undef,
6165							'patcount' => 0,
6166							'actcount' => 0,
6167							'items' => [
6168							bless( {
6169							'pattern' => 'sin',
6170							'hashname' => '__STRING1__',
6171							'description' => '\'sin\'',
6172							'lookahead' => 0,
6173							'line' => 185
6174							}, 'Parse::RecDescent::Literal' )
6175							],
6176							'line' => 185
6177							}, 'Parse::RecDescent::Production' ),
6178							bless( {
6179							'number' => 13,
6180							'strcount' => 1,
6181							'dircount' => 0,
6182							'uncommit' => undef,
6183							'error' => undef,
6184							'patcount' => 0,
6185							'actcount' => 0,
6186							'items' => [
6187							bless( {
6188							'pattern' => 'cos',
6189							'hashname' => '__STRING1__',
6190							'description' => '\'cos\'',
6191							'lookahead' => 0,
6192							'line' => 186
6193							}, 'Parse::RecDescent::Literal' )
6194							],
6195							'line' => 186
6196							}, 'Parse::RecDescent::Production' ),
6197							bless( {
6198							'number' => 14,
6199							'strcount' => 1,
6200							'dircount' => 0,
6201							'uncommit' => undef,
6202							'error' => undef,
6203							'patcount' => 0,
6204							'actcount' => 0,
6205							'items' => [
6206							bless( {
6207							'pattern' => 'tan',
6208							'hashname' => '__STRING1__',
6209							'description' => '\'tan\'',
6210							'lookahead' => 0,
6211							'line' => 187
6212							}, 'Parse::RecDescent::Literal' )
6213							],
6214							'line' => 187
6215							}, 'Parse::RecDescent::Production' ),
6216							bless( {
6217							'number' => 15,
6218							'strcount' => 1,
6219							'dircount' => 0,
6220							'uncommit' => undef,
6221							'error' => undef,
6222							'patcount' => 0,
6223							'actcount' => 0,
6224							'items' => [
6225							bless( {
6226							'pattern' => 'cot',
6227							'hashname' => '__STRING1__',
6228							'description' => '\'cot\'',
6229							'lookahead' => 0,
6230							'line' => 188
6231							}, 'Parse::RecDescent::Literal' )
6232							],
6233							'line' => 188
6234							}, 'Parse::RecDescent::Production' ),
6235							bless( {
6236							'number' => 16,
6237							'strcount' => 1,
6238							'dircount' => 0,
6239							'uncommit' => undef,
6240							'error' => undef,
6241							'patcount' => 0,
6242							'actcount' => 0,
6243							'items' => [
6244							bless( {
6245							'pattern' => 'exp',
6246							'hashname' => '__STRING1__',
6247							'description' => '\'exp\'',
6248							'lookahead' => 0,
6249							'line' => 189
6250							}, 'Parse::RecDescent::Literal' )
6251							],
6252							'line' => 189
6253							}, 'Parse::RecDescent::Production' ),
6254							bless( {
6255							'number' => 17,
6256							'strcount' => 1,
6257							'dircount' => 0,
6258							'uncommit' => undef,
6259							'error' => undef,
6260							'patcount' => 0,
6261							'actcount' => 0,
6262							'items' => [
6263							bless( {
6264							'pattern' => 'sqrt',
6265							'hashname' => '__STRING1__',
6266							'description' => '\'sqrt\'',
6267							'lookahead' => 0,
6268							'line' => 190
6269							}, 'Parse::RecDescent::Literal' )
6270							],
6271							'line' => 190
6272							}, 'Parse::RecDescent::Production' )
6273							],
6274							'name' => 'function_name',
6275							'vars' => '',
6276							'changed' => 0,
6277							'line' => 173
6278							}, 'Parse::RecDescent::Rule' ),
6279							'add_op' => bless( {
6280							'impcount' => 0,
6281							'calls' => [],
6282							'opcount' => 0,
6283							'prods' => [
6284							bless( {
6285							'number' => 0,
6286							'strcount' => 1,
6287							'dircount' => 0,
6288							'uncommit' => undef,
6289							'error' => undef,
6290							'patcount' => 0,
6291							'actcount' => 0,
6292							'items' => [
6293							bless( {
6294							'pattern' => '+',
6295							'hashname' => '__STRING1__',
6296							'description' => '\'+\'',
6297							'lookahead' => 0,
6298							'line' => 32
6299							}, 'Parse::RecDescent::Literal' )
6300							],
6301							'line' => undef
6302							}, 'Parse::RecDescent::Production' ),
6303							bless( {
6304							'number' => 1,
6305							'strcount' => 1,
6306							'dircount' => 0,
6307							'uncommit' => undef,
6308							'error' => undef,
6309							'patcount' => 0,
6310							'actcount' => 0,
6311							'items' => [
6312							bless( {
6313							'pattern' => '-',
6314							'hashname' => '__STRING1__',
6315							'description' => '\'-\'',
6316							'lookahead' => 0,
6317							'line' => 33
6318							}, 'Parse::RecDescent::Literal' )
6319							],
6320							'line' => 33
6321							}, 'Parse::RecDescent::Production' )
6322							],
6323							'name' => 'add_op',
6324							'vars' => '',
6325							'changed' => 0,
6326							'line' => 32
6327							}, 'Parse::RecDescent::Rule' ),
6328							'expr_list' => bless( {
6329							'impcount' => 0,
6330							'calls' => [
6331							'expr'
6332							],
6333							'opcount' => 0,
6334							'prods' => [
6335							bless( {
6336							'number' => 0,
6337							'strcount' => 1,
6338							'dircount' => 1,
6339							'uncommit' => undef,
6340							'error' => undef,
6341							'patcount' => 0,
6342							'actcount' => 1,
6343							'op' => [],
6344							'items' => [
6345							bless( {
6346							'expected' => '',
6347							'min' => 1,
6348							'name' => '',
6349							'max' => 100000000,
6350							'leftarg' => bless( {
6351							'subrule' => 'expr',
6352							'matchrule' => 0,
6353							'implicit' => undef,
6354							'argcode' => undef,
6355							'lookahead' => 0,
6356							'line' => 193
6357							}, 'Parse::RecDescent::Subrule' ),
6358							'rightarg' => bless( {
6359							'subrule' => 'expr',
6360							'matchrule' => 0,
6361							'implicit' => undef,
6362							'argcode' => undef,
6363							'lookahead' => 0,
6364							'line' => 193
6365							}, 'Parse::RecDescent::Subrule' ),
6366							'hashname' => '__DIRECTIVE1__',
6367							'type' => 'leftop',
6368							'op' => bless( {
6369							'pattern' => ',',
6370							'hashname' => '__STRING1__',
6371							'description' => '\',\'',
6372							'lookahead' => 0,
6373							'line' => 193
6374							}, 'Parse::RecDescent::Literal' )
6375							}, 'Parse::RecDescent::Operator' ),
6376							bless( {
6377							'hashname' => '__ACTION1__',
6378							'lookahead' => 0,
6379							'line' => 194,
6380							'code' => '{
6381							#warn \'expr_list \'
6382							# if $Math::Symbolic::Parser::DEBUG;
6383							$item[1]
6384							}'
6385							}, 'Parse::RecDescent::Action' )
6386							],
6387							'line' => undef
6388							}, 'Parse::RecDescent::Production' )
6389							],
6390							'name' => 'expr_list',
6391							'vars' => '',
6392							'changed' => 0,
6393							'line' => 193
6394							}, 'Parse::RecDescent::Rule' )
6395							},
6396							'_AUTOTREE' => undef,
6397							'_check' => {
6398							'thisoffset' => '',
6399							'itempos' => '',
6400							'prevoffset' => '',
6401							'prevline' => '',
6402							'prevcolumn' => '',
6403							'thiscolumn' => ''
6404							},
6405							'_AUTOACTION' => undef
6406							}, 'Parse::RecDescent' );
6407							}
6408							1;