File Coverage

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

Criterion	Covered	Total	%
statement	2015	2271	88.7
branch	629	1338	47.0
condition	191	370	51.6
subroutine	72	73	98.6
pod	0	1	0.0
total	2907	4053	71.7

line	stmt	bran	cond	sub	pod	time	code
1							package Math::Symbolic::Parser::Precompiled;
2							our $VERSION = '0.613';
3
4	23			23		223	use strict;
	23					51
	23					1470
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		135	use Parse::RecDescent;
	23					82
	23					220
52							{ my $ERRORS;
53
54
55							package Parse::RecDescent::Math::Symbolic::Parser::Precompiled;
56	23			23		1605	use strict;
	23					48
	23					648
57	23			23		109	use vars qw($skip $AUTOLOAD );
	23					49
	23					2605
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		148	no strict 'refs';
	23					52
	23					3437
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	2922			2922		5382	my $thisparser = $_[0];
79	23			23		163	use vars q{$tracelevel};
	23					50
	23					12672
80	2922		50			7901	local $tracelevel = ($tracelevel\|\|0)+1;
81	2922					4556	$ERRORS = 0;
82	2922					7638	my $thisrule = $thisparser->{"rules"}{"exp"};
83
84	2922	50				6516	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	2922					5175	my $err_at = @{$thisparser->{errors}};
	2922					7340
92
93	2922					10748	my $score;
94							my $score_return;
95	2922					0	my $_tok;
96	2922					4419	my $return = undef;
97	2922					4735	my $_matched=0;
98	2922					4654	my $commit=0;
99	2922					4808	my @item = ();
100	2922					4977	my %item = ();
101	2922					4692	my $repeating = $_[2];
102	2922					4614	my $_noactions = $_[3];
103	2922	50				7661	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2922					4415
	2922					5554
104	2922					5043	my $_itempos = $_[5];
105	2922	50				7708	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
106	2922					8308	my $text;
107							my $lastsep;
108	2922					0	my $current_match;
109	2922					8814	my $expectation = new Parse::RecDescent::Expectation(q{});
110	2922					26089	$expectation->at($_[1]);
111
112	2922					12715	my $thisline;
113	2922					10737	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
114
115
116
117	2922		33			29835	while (!$_matched && !$commit)
118							{
119
120	2922	50				6874	Parse::RecDescent::_trace(q{Trying production: []},
121							Parse::RecDescent::_tracefirst($_[1]),
122							q{exp},
123							$tracelevel)
124							if defined $::RD_TRACE;
125	2922					11918	my $thisprod = $thisrule->{"prods"}[0];
126	2922					5244	$text = $_[1];
127	2922					4348	my $_savetext;
128	2922					6609	@item = (q{exp});
129	2922					7821	%item = (__RULE__ => q{exp});
130	2922					4678	my $repcount = 0;
131
132
133	2922	50				6223	Parse::RecDescent::_trace(q{Trying operator: []},
134							Parse::RecDescent::_tracefirst($text),
135							q{exp},
136							$tracelevel)
137							if defined $::RD_TRACE;
138	2922					7792	$expectation->is(q{})->at($text);
139
140	2922					20951	$_tok = undef;
141	2922					4466	OPLOOP: while (1)
142							{
143	2922					4540	$repcount = 0;
144	2922					5276	my @item;
145							my %item;
146
147	2922					23328	my $savetext = $text;
148	2922					4507	my $backtrack;
149							# MATCH (LEFTARG OP)(s)
150	2922					7046	while ($repcount < 100000000)
151							{
152	3201					4955	$backtrack = 0;
153
154	3201	50				7319	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		206	if (1) { no strict qw{refs};
	23					54
	23					12010
	3201					4960
160	3201					8227	$expectation->is(q{factor})->at($text);
161	3201	50		3201		34985	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	3201					6460
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	3201	50				14573	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	3201					11748	$item{q{factor}} = $_tok;
180	3201					5952	push @item, $_tok;
181
182							}
183
184
185	3201					5512	$repcount++;
186	3201					5191	$backtrack = 1;
187
188	3201	50				6507	Parse::RecDescent::_trace(q{Trying terminal: ['^']},
189							Parse::RecDescent::_tracefirst($text),
190							q{exp},
191							$tracelevel)
192							if defined $::RD_TRACE;
193	3201					5696	undef $lastsep;
194	3201					10832	$expectation->is(q{'^'})->at($text);
195
196
197	3201	50	66			47872	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\^/)
	3201	100				25006
198							{
199	2922	50				7822	$text = $lastsep . $text if defined $lastsep;
200
201	2922					9477	$expectation->failed();
202	2922	50				29261	Parse::RecDescent::_trace(qq{<>},
203							Parse::RecDescent::_tracefirst($text))
204							if defined $::RD_TRACE;
205	2922					5822	last;
206							}
207	279					1565	$current_match = substr($text, $-[0], $+[0] - $-[0]);
208	279					951	substr($text,0,length($current_match),q{});
209	279	50				792	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
210							. $current_match . q{])},
211							Parse::RecDescent::_tracefirst($text))
212							if defined $::RD_TRACE;
213	279					943	push @item, $item{__STRING1__}=$current_match;
214
215
216	279					532	$savetext = $text;
217	279					872	pop @item;
218
219							}
220	2922					6125	$text = $savetext;
221	2922	50				7479	pop @item if $backtrack;
222
223							# MATCH RIGHTARG
224
225	2922	50				6599	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		190	if (1) { no strict qw{refs};
	23					68
	23					23888
	2922					4307
231	2922					11817	$expectation->is(q{factor})->at($text);
232	2922	50		2922		41127	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::factor($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2922					6346
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	2922	50				11665	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	2922					9358	$item{q{factor}} = $_tok;
251	2922					10809	push @item, $_tok;
252
253							}
254
255	2922					5640	$repcount++;
256	2922	50				6624	unless (@item) { undef $_tok; last }
	0					0
	0					0
257	2922					6945	$_tok = [ @item ];
258
259	2922					7419	last;
260							} # end of OPLOOP
261
262	2922	50				7479	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	2922	50				6501	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	2922		50			10637	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
280
281	2922	50				6670	Parse::RecDescent::_trace(q{Trying action},
282							Parse::RecDescent::_tracefirst($text),
283							q{exp},
284							$tracelevel)
285							if defined $::RD_TRACE;
286
287
288	2922	50				5956	$_tok = ($_noactions) ? 0 : do {
289							#warn 'exp ' if $Math::Symbolic::Parser::DEBUG;
290	2922	100				4320	if (@{$item[1]} == 1) {
	2922					7295
291	2646					6189	$item[1][0]
292							}
293							else {
294	276					551	my @it = reverse @{$item[1]};
	276					906
295	276					626	my $tree = shift @it;
296	276					894	while (@it) {
297	279					1868	$tree = Math::Symbolic::Operator->new(
298							'^', shift(@it), $tree
299							);
300							}
301	276					872	$tree;
302							}
303							};
304	2922	50				6534	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	2922	50				6888	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
311							. $_tok . q{])},
312							Parse::RecDescent::_tracefirst($text))
313							if defined $::RD_TRACE;
314	2922					5014	push @item, $_tok;
315	2922					5852	$item{__ACTION1__}=$_tok;
316
317
318	2922	50				5911	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	2922					4874	$_matched = 1;
327	2922					5744	last;
328							}
329
330
331	2922	50	33			8548	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	2922	50	33			11847	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	2922					4661	splice @{$thisparser->{errors}}, $err_at;
	2922					7235
352	2922	50				7664	$return = $item[$#item] unless defined $return;
353	2922	50				6108	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	2922					6053	$_[1] = $text;
366	2922					24426	return $return;
367							}
368
369							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
370							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::variable
371							{
372	3835			3835		6449	my $thisparser = $_[0];
373	23			23		216	use vars q{$tracelevel};
	23					106
	23					28461
374	3835		50			9612	local $tracelevel = ($tracelevel\|\|0)+1;
375	3835					6295	$ERRORS = 0;
376	3835					9936	my $thisrule = $thisparser->{"rules"}{"variable"};
377
378	3835	50				10293	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	3835					5586	my $err_at = @{$thisparser->{errors}};
	3835					9775
386
387	3835					9917	my $score;
388							my $score_return;
389	3835					0	my $_tok;
390	3835					5902	my $return = undef;
391	3835					6010	my $_matched=0;
392	3835					6300	my $commit=0;
393	3835					6629	my @item = ();
394	3835					6892	my %item = ();
395	3835					6348	my $repeating = $_[2];
396	3835					8078	my $_noactions = $_[3];
397	3835	50				8886	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	3835					5800
	3835					7227
398	3835					6231	my $_itempos = $_[5];
399	3835	50				10203	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
400	3835					9254	my $text;
401							my $lastsep;
402	3835					0	my $current_match;
403	3835					12870	my $expectation = new Parse::RecDescent::Expectation(q{/[a-zA-Z][a-zA-Z0-9_]*/});
404	3835					36531	$expectation->at($_[1]);
405
406	3835					17138	my $thisline;
407	3835					18011	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
408
409
410
411	3835		33			35223	while (!$_matched && !$commit)
412							{
413
414	3835	50				8135	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	3835					9787	my $thisprod = $thisrule->{"prods"}[0];
420	3835					6799	$text = $_[1];
421	3835					5428	my $_savetext;
422	3835					8936	@item = (q{variable});
423	3835					8575	%item = (__RULE__ => q{variable});
424	3835					6489	my $repcount = 0;
425
426
427	3835	50				11550	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	3835					6522	undef $lastsep;
432	3835					13670	$expectation->is(q{})->at($text);
433
434
435	3835	50	66			47984	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	3835	100				28399
436							{
437	631	50				1937	$text = $lastsep . $text if defined $lastsep;
438	631					2088	$expectation->failed();
439	631	50				2679	Parse::RecDescent::_trace(q{<>},
440							Parse::RecDescent::_tracefirst($text))
441							if defined $::RD_TRACE;
442
443	631					1467	last;
444							}
445	3204					16303	$current_match = substr($text, $-[0], $+[0] - $-[0]);
446	3204					8696	substr($text,0,length($current_match),q{});
447	3204	50				6968	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
448							. $current_match . q{])},
449							Parse::RecDescent::_tracefirst($text))
450							if defined $::RD_TRACE;
451	3204					8676	push @item, $item{__PATTERN1__}=$current_match;
452
453
454	3204	50				6485	Parse::RecDescent::_trace(q{Trying terminal: [/\\'*/]}, Parse::RecDescent::_tracefirst($text),
455							q{variable},
456							$tracelevel)
457							if defined $::RD_TRACE;
458	3204					5400	undef $lastsep;
459	3204					7737	$expectation->is(q{/\\'*/})->at($text);
460
461
462	3204	50	33			37199	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\'*)/)
	3204	50				23157
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	3204					17302	$current_match = substr($text, $-[0], $+[0] - $-[0]);
473	3204					7841	substr($text,0,length($current_match),q{});
474	3204	50				6973	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
475							. $current_match . q{])},
476							Parse::RecDescent::_tracefirst($text))
477							if defined $::RD_TRACE;
478	3204					8034	push @item, $item{__PATTERN2__}=$current_match;
479
480
481	3204	50				6215	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
482							Parse::RecDescent::_tracefirst($text),
483							q{variable},
484							$tracelevel)
485							if defined $::RD_TRACE;
486	3204					5183	undef $lastsep;
487	3204					7881	$expectation->is(q{'('})->at($text);
488
489
490	3204	50	66			32070	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	3204	100				21539
491							{
492	3045	50				8600	$text = $lastsep . $text if defined $lastsep;
493
494	3045					10305	$expectation->failed();
495	3045	50				33200	Parse::RecDescent::_trace(qq{<>},
496							Parse::RecDescent::_tracefirst($text))
497							if defined $::RD_TRACE;
498	3045					7484	last;
499							}
500	159					664	$current_match = substr($text, $-[0], $+[0] - $-[0]);
501	159					419	substr($text,0,length($current_match),q{});
502	159	50				322	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
503							. $current_match . q{])},
504							Parse::RecDescent::_tracefirst($text))
505							if defined $::RD_TRACE;
506	159					476	push @item, $item{__STRING1__}=$current_match;
507
508
509	159	50				340	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		234	if (1) { no strict qw{refs};
	23					53
	23					42954
	159					226
515	159					404	$expectation->is(q{identifier_list})->at($text);
516	159	50		159		1748	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::identifier_list($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	159					348
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				694	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					341	$item{q{identifier_list}} = $_tok;
535	159					332	push @item, $_tok;
536
537							}
538
539	159	50				425	Parse::RecDescent::_trace(q{Trying terminal: [')']},
540							Parse::RecDescent::_tracefirst($text),
541							q{variable},
542							$tracelevel)
543							if defined $::RD_TRACE;
544	159					295	undef $lastsep;
545	159					491	$expectation->is(q{')'})->at($text);
546
547
548	159	50	33			2028	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	159	50				1249
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					800	$current_match = substr($text, $-[0], $+[0] - $-[0]);
559	159					406	substr($text,0,length($current_match),q{});
560	159	50				319	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
561							. $current_match . q{])},
562							Parse::RecDescent::_tracefirst($text))
563							if defined $::RD_TRACE;
564	159					510	push @item, $item{__STRING2__}=$current_match;
565
566
567	159	50				327	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				313	$_tok = ($_noactions) ? 0 : do {
575							#warn 'variable '
576							# if $Math::Symbolic::Parser::DEBUG;
577	159					289	my $varname = $item[1];
578	159					246	my $ticks = $item[2];
579	159	100				371	if ($ticks) {
580	12					50	my $n = length($ticks);
581	12		50			36	my $sig = $item[4] \|\| ['x'];
582	12					27	my $dep_var = $sig->[0];
583	12					157	my $return = Math::Symbolic::Variable->new(
584							{ name => $varname, signature => $sig }
585							);
586	12					64	foreach (1..$n) {
587	18					115	$return = Math::Symbolic::Operator->new(
588							'partial_derivative',
589							$return, $dep_var,
590							);
591							}
592	12					42	$return;
593							}
594							else {
595	147					962	Math::Symbolic::Variable->new(
596							{ name => $varname, signature => $item[4] }
597							);
598							}
599							};
600	159	50				368	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				332	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
607							. $_tok . q{])},
608							Parse::RecDescent::_tracefirst($text))
609							if defined $::RD_TRACE;
610	159					313	push @item, $_tok;
611	159					385	$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					261	$_matched = 1;
623	159					294	last;
624							}
625
626
627	3835		66			14322	while (!$_matched && !$commit)
628							{
629
630	3676	50				7074	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	3676					8342	my $thisprod = $thisrule->{"prods"}[1];
636	3676					6676	$text = $_[1];
637	3676					5843	my $_savetext;
638	3676					9258	@item = (q{variable});
639	3676					11988	%item = (__RULE__ => q{variable});
640	3676					5628	my $repcount = 0;
641
642
643	3676	50				8956	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	3676					6065	undef $lastsep;
648	3676					8594	$expectation->is(q{})->at($text);
649
650
651	3676	50	66			40118	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	3676	100				28001
652							{
653	631	50				1911	$text = $lastsep . $text if defined $lastsep;
654	631					2096	$expectation->failed();
655	631	50				2556	Parse::RecDescent::_trace(q{<>},
656							Parse::RecDescent::_tracefirst($text))
657							if defined $::RD_TRACE;
658
659	631					1285	last;
660							}
661	3045					13186	$current_match = substr($text, $-[0], $+[0] - $-[0]);
662	3045					7772	substr($text,0,length($current_match),q{});
663	3045	50				6667	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
664							. $current_match . q{])},
665							Parse::RecDescent::_tracefirst($text))
666							if defined $::RD_TRACE;
667	3045					8928	push @item, $item{__PATTERN1__}=$current_match;
668
669
670	3045	50				7401	Parse::RecDescent::_trace(q{Trying terminal: [/\\'*/]}, Parse::RecDescent::_tracefirst($text),
671							q{variable},
672							$tracelevel)
673							if defined $::RD_TRACE;
674	3045					4630	undef $lastsep;
675	3045					7986	$expectation->is(q{/\\'*/})->at($text);
676
677
678	3045	50	33			31395	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\'*)/)
	3045	50				20251
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	3045					11990	$current_match = substr($text, $-[0], $+[0] - $-[0]);
689	3045					7733	substr($text,0,length($current_match),q{});
690	3045	50				6165	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
691							. $current_match . q{])},
692							Parse::RecDescent::_tracefirst($text))
693							if defined $::RD_TRACE;
694	3045					7332	push @item, $item{__PATTERN2__}=$current_match;
695
696
697	3045	50				6574	Parse::RecDescent::_trace(q{Trying action},
698							Parse::RecDescent::_tracefirst($text),
699							q{variable},
700							$tracelevel)
701							if defined $::RD_TRACE;
702
703
704	3045	50				6494	$_tok = ($_noactions) ? 0 : do {
705							#warn 'variable '
706							# if $Math::Symbolic::Parser::DEBUG;
707	3045					5889	my $varname = $item[1];
708	3045					4692	my $ticks = $item[2];
709	3045	100				7069	if ($ticks) {
710	4					9	my $n = length($ticks);
711	4					38	my $return = Math::Symbolic::Variable->new(
712							{ name => $varname, signature => ['x'] }
713							);
714	4					24	foreach (1..$n) {
715	6					32	$return = Math::Symbolic::Operator->new(
716							'partial_derivative',
717							$return, 'x',
718							);
719							}
720	4					14	$return;
721							}
722							else {
723	3041					14275	Math::Symbolic::Variable->new( $varname );
724							}
725							};
726	3045	50				7689	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	3045	50				6215	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
733							. $_tok . q{])},
734							Parse::RecDescent::_tracefirst($text))
735							if defined $::RD_TRACE;
736	3045					4925	push @item, $_tok;
737	3045					6301	$item{__ACTION1__}=$_tok;
738
739
740	3045	50				5947	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	3045					4763	$_matched = 1;
749	3045					5966	last;
750							}
751
752
753	3835	100	66			11022	unless ( $_matched \|\| defined($score) )
754							{
755
756
757	631					1417	$_[1] = $text; # NOT SURE THIS IS NEEDED
758	631	50				1458	Parse::RecDescent::_trace(q{<>},
759							Parse::RecDescent::_tracefirst($_[1]),
760							q{variable},
761							$tracelevel)
762							if defined $::RD_TRACE;
763	631					4662	return undef;
764							}
765	3204	50	33			12259	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	3204					5942	splice @{$thisparser->{errors}}, $err_at;
	3204					9109
774	3204	50				8416	$return = $item[$#item] unless defined $return;
775	3204	50				6864	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	3204					7116	$_[1] = $text;
788	3204					28273	return $return;
789							}
790
791							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
792							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function
793							{
794	4325			4325		11436	my $thisparser = $_[0];
795	23			23		295	use vars q{$tracelevel};
	23					63
	23					10018
796	4325		50			11249	local $tracelevel = ($tracelevel\|\|0)+1;
797	4325					6570	$ERRORS = 0;
798	4325					10504	my $thisrule = $thisparser->{"rules"}{"function"};
799
800	4325	50				9607	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	4325					7517	my $err_at = @{$thisparser->{errors}};
	4325					9409
808
809	4325					10707	my $score;
810							my $score_return;
811	4325					0	my $_tok;
812	4325					7149	my $return = undef;
813	4325					6645	my $_matched=0;
814	4325					6178	my $commit=0;
815	4325					10060	my @item = ();
816	4325					8555	my %item = ();
817	4325					6543	my $repeating = $_[2];
818	4325					6904	my $_noactions = $_[3];
819	4325	50				9242	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	4325					6399
	4325					9293
820	4325					7974	my $_itempos = $_[5];
821	4325	50				10936	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
822	4325					10954	my $text;
823							my $lastsep;
824	4325					0	my $current_match;
825	4325					13096	my $expectation = new Parse::RecDescent::Expectation(q{function_name});
826	4325					38835	$expectation->at($_[1]);
827
828	4325					18058	my $thisline;
829	4325					22030	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
830
831
832
833	4325		33			39815	while (!$_matched && !$commit)
834							{
835
836	4325	50				9347	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	4325					10196	my $thisprod = $thisrule->{"prods"}[0];
842	4325					7316	$text = $_[1];
843	4325					7217	my $_savetext;
844	4325					9004	@item = (q{function});
845	4325					9553	%item = (__RULE__ => q{function});
846	4325					6585	my $repcount = 0;
847
848
849	4325	50				8659	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		190	if (1) { no strict qw{refs};
	23					52
	23					9479
	4325					6376
855	4325					10154	$expectation->is(q{})->at($text);
856	4325	100		4325		45719	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function_name($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	4325					8823
857							{
858
859	3835	50				13734	Parse::RecDescent::_trace(q{<>},
860							Parse::RecDescent::_tracefirst($text),
861							q{function},
862							$tracelevel)
863							if defined $::RD_TRACE;
864	3835					11180	$expectation->failed();
865	3835					22488	last;
866							}
867	490	50				2651	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					1587	$item{q{function_name}} = $_tok;
875	490					1206	push @item, $_tok;
876
877							}
878
879	490	50				1184	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
880							Parse::RecDescent::_tracefirst($text),
881							q{function},
882							$tracelevel)
883							if defined $::RD_TRACE;
884	490					924	undef $lastsep;
885	490					1720	$expectation->is(q{'('})->at($text);
886
887
888	490	50	33			6963	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	490	50				4453
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					2658	$current_match = substr($text, $-[0], $+[0] - $-[0]);
899	490					1589	substr($text,0,length($current_match),q{});
900	490	50				1312	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
901							. $current_match . q{])},
902							Parse::RecDescent::_tracefirst($text))
903							if defined $::RD_TRACE;
904	490					1636	push @item, $item{__STRING1__}=$current_match;
905
906
907	490	50				1313	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		174	if (1) { no strict qw{refs};
	23					99
	23					26045
	490					830
913	490					4435	$expectation->is(q{expr_list})->at($text);
914	490	50		490		6029	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr_list($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	490					1293
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				2489	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					1526	$item{q{expr_list}} = $_tok;
933	490					1071	push @item, $_tok;
934
935							}
936
937	490	50				1171	Parse::RecDescent::_trace(q{Trying terminal: [')']},
938							Parse::RecDescent::_tracefirst($text),
939							q{function},
940							$tracelevel)
941							if defined $::RD_TRACE;
942	490					975	undef $lastsep;
943	490					1758	$expectation->is(q{')'})->at($text);
944
945
946	490	50	33			7484	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	490	50				4618
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					3012	$current_match = substr($text, $-[0], $+[0] - $-[0]);
957	490					1688	substr($text,0,length($current_match),q{});
958	490	50				1259	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
959							. $current_match . q{])},
960							Parse::RecDescent::_tracefirst($text))
961							if defined $::RD_TRACE;
962	490					1608	push @item, $item{__STRING2__}=$current_match;
963
964
965	490	50				1263	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				1759	$_tok = ($_noactions) ? 0 : do {
973							#warn 'function '
974							# if $Math::Symbolic::Parser::DEBUG;
975	490					1131	my $fname = $item[1];
976	490					824	my $function;
977	490	100				1833	if (exists($Math::Symbolic::Parser::Parser_Functions{$fname})) {
978	8					18	$function = $Math::Symbolic::Parser::Parser_Functions{$fname}->($fname, @{$item[3]});
	8					73
979	8	50				43	die "Invalid function '$fname'!"
980							unless defined $function;
981							}
982							else {
983	482					1625	$function = $Math::Symbolic::Operator::Op_Symbols{ $fname };
984	482	50				1303	die "Invalid function '$fname'!"
985							unless defined $function;
986	482					4220	$function = Math::Symbolic::Operator->new(
987							{ type => $function, operands => $item[3] }
988							);
989							}
990	490					1786	$function
991							};
992	490	50				1357	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				1243	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
999							. $_tok . q{])},
1000							Parse::RecDescent::_tracefirst($text))
1001							if defined $::RD_TRACE;
1002	490					1148	push @item, $_tok;
1003	490					1198	$item{__ACTION1__}=$_tok;
1004
1005
1006	490	50				1197	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					885	$_matched = 1;
1015	490					1070	last;
1016							}
1017
1018
1019	4325	100	66			26785	unless ( $_matched \|\| defined($score) )
1020							{
1021
1022
1023	3835					7939	$_[1] = $text; # NOT SURE THIS IS NEEDED
1024	3835	50				7720	Parse::RecDescent::_trace(q{<>},
1025							Parse::RecDescent::_tracefirst($_[1]),
1026							q{function},
1027							$tracelevel)
1028							if defined $::RD_TRACE;
1029	3835					24821	return undef;
1030							}
1031	490	50	33			2099	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					903	splice @{$thisparser->{errors}}, $err_at;
	490					1323
1040	490	50				1495	$return = $item[$#item] unless defined $return;
1041	490	50				1282	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					1450	$_[1] = $text;
1054	490					5383	return $return;
1055							}
1056
1057							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1058							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::number
1059							{
1060	6123			6123		10614	my $thisparser = $_[0];
1061	23			23		230	use vars q{$tracelevel};
	23					73
	23					26402
1062	6123		50			16378	local $tracelevel = ($tracelevel\|\|0)+1;
1063	6123					10112	$ERRORS = 0;
1064	6123					13650	my $thisrule = $thisparser->{"rules"}{"number"};
1065
1066	6123	50				13159	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	6123					9634	my $err_at = @{$thisparser->{errors}};
	6123					13019
1074
1075	6123					15488	my $score;
1076							my $score_return;
1077	6123					0	my $_tok;
1078	6123					10150	my $return = undef;
1079	6123					9494	my $_matched=0;
1080	6123					8905	my $commit=0;
1081	6123					10348	my @item = ();
1082	6123					10884	my %item = ();
1083	6123					9348	my $repeating = $_[2];
1084	6123					9841	my $_noactions = $_[3];
1085	6123	50				17127	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	6123					9188
	6123					11531
1086	6123					11982	my $_itempos = $_[5];
1087	6123	50				16108	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1088	6123					15274	my $text;
1089							my $lastsep;
1090	6123					0	my $current_match;
1091	6123					18680	my $expectation = new Parse::RecDescent::Expectation(q{/([+-]?)(?=\\d\|\\.\\d)\\d(\\.\\d)?([Ee]([+-]?\\d+))?/});
1092	6123					58701	$expectation->at($_[1]);
1093
1094	6123					28194	my $thisline;
1095	6123					22801	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1096
1097
1098
1099	6123		33			54505	while (!$_matched && !$commit)
1100							{
1101
1102	6123	50				13061	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	6123					16354	my $thisprod = $thisrule->{"prods"}[0];
1108	6123					10341	$text = $_[1];
1109	6123					9246	my $_savetext;
1110	6123					12880	@item = (q{number});
1111	6123					13578	%item = (__RULE__ => q{number});
1112	6123					9762	my $repcount = 0;
1113
1114
1115	6123	50				12120	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	6123					10780	undef $lastsep;
1120	6123					14517	$expectation->is(q{})->at($text);
1121
1122
1123	6123	50	66			82614	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:([+-]?)(?=\d\|\.\d)\d(\.\d)?([Ee]([+-]?\d+))?)/)
	6123	100				61191
1124							{
1125	4325	50				13417	$text = $lastsep . $text if defined $lastsep;
1126	4325					13739	$expectation->failed();
1127	4325	50				18351	Parse::RecDescent::_trace(q{<>},
1128							Parse::RecDescent::_tracefirst($text))
1129							if defined $::RD_TRACE;
1130
1131	4325					12159	last;
1132							}
1133	1798					9664	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1134	1798					6750	substr($text,0,length($current_match),q{});
1135	1798	50				4522	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1136							. $current_match . q{])},
1137							Parse::RecDescent::_tracefirst($text))
1138							if defined $::RD_TRACE;
1139	1798					5454	push @item, $item{__PATTERN1__}=$current_match;
1140
1141
1142	1798	50				4074	Parse::RecDescent::_trace(q{Trying action},
1143							Parse::RecDescent::_tracefirst($text),
1144							q{number},
1145							$tracelevel)
1146							if defined $::RD_TRACE;
1147
1148
1149	1798	50				3900	$_tok = ($_noactions) ? 0 : do {
1150							#warn 'number '
1151							# if $Math::Symbolic::Parser::DEBUG;
1152	1798					8796	Math::Symbolic::Constant->new($item[1])
1153							};
1154	1798	50				4425	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	1798	50				4171	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1161							. $_tok . q{])},
1162							Parse::RecDescent::_tracefirst($text))
1163							if defined $::RD_TRACE;
1164	1798					4148	push @item, $_tok;
1165	1798					4146	$item{__ACTION1__}=$_tok;
1166
1167
1168	1798	50				4050	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	1798					3038	$_matched = 1;
1177	1798					3759	last;
1178							}
1179
1180
1181	6123	100	66			20754	unless ( $_matched \|\| defined($score) )
1182							{
1183
1184
1185	4325					8704	$_[1] = $text; # NOT SURE THIS IS NEEDED
1186	4325	50				9824	Parse::RecDescent::_trace(q{<>},
1187							Parse::RecDescent::_tracefirst($_[1]),
1188							q{number},
1189							$tracelevel)
1190							if defined $::RD_TRACE;
1191	4325					34917	return undef;
1192							}
1193	1798	50	33			7468	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	1798					2902	splice @{$thisparser->{errors}}, $err_at;
	1798					5353
1202	1798	50				4903	$return = $item[$#item] unless defined $return;
1203	1798	50				6290	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	1798					4102	$_[1] = $text;
1216	1798					15844	return $return;
1217							}
1218
1219							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1220							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::multiplication
1221							{
1222	2271			2271		4613	my $thisparser = $_[0];
1223	23			23		213	use vars q{$tracelevel};
	23					67
	23					10685
1224	2271		50			7929	local $tracelevel = ($tracelevel\|\|0)+1;
1225	2271					3829	$ERRORS = 0;
1226	2271					9580	my $thisrule = $thisparser->{"rules"}{"multiplication"};
1227
1228	2271	50				5194	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	2271					3636	my $err_at = @{$thisparser->{errors}};
	2271					5022
1236
1237	2271					6021	my $score;
1238							my $score_return;
1239	2271					0	my $_tok;
1240	2271					4027	my $return = undef;
1241	2271					4087	my $_matched=0;
1242	2271					3814	my $commit=0;
1243	2271					3957	my @item = ();
1244	2271					3876	my %item = ();
1245	2271					3740	my $repeating = $_[2];
1246	2271					3801	my $_noactions = $_[3];
1247	2271	50				6460	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2271					3731
	2271					4487
1248	2271					4163	my $_itempos = $_[5];
1249	2271	50				8028	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1250	2271					5898	my $text;
1251							my $lastsep;
1252	2271					0	my $current_match;
1253	2271					6952	my $expectation = new Parse::RecDescent::Expectation(q{});
1254	2271					19587	$expectation->at($_[1]);
1255
1256	2271					9857	my $thisline;
1257	2271					8284	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1258
1259
1260
1261	2271		33			19241	while (!$_matched && !$commit)
1262							{
1263
1264	2271	50				6081	Parse::RecDescent::_trace(q{Trying production: []},
1265							Parse::RecDescent::_tracefirst($_[1]),
1266							q{multiplication},
1267							$tracelevel)
1268							if defined $::RD_TRACE;
1269	2271					5777	my $thisprod = $thisrule->{"prods"}[0];
1270	2271					3999	$text = $_[1];
1271	2271					3750	my $_savetext;
1272	2271					6838	@item = (q{multiplication});
1273	2271					5270	%item = (__RULE__ => q{multiplication});
1274	2271					3803	my $repcount = 0;
1275
1276
1277	2271	50				5080	Parse::RecDescent::_trace(q{Trying operator: []},
1278							Parse::RecDescent::_tracefirst($text),
1279							q{multiplication},
1280							$tracelevel)
1281							if defined $::RD_TRACE;
1282	2271					5743	$expectation->is(q{})->at($text);
1283
1284	2271					25958	$_tok = undef;
1285	2271					3682	OPLOOP: while (1)
1286							{
1287	2271					3395	$repcount = 0;
1288	2271					4409	my @item;
1289							my %item;
1290
1291							# MATCH LEFTARG
1292
1293	2271	50				5412	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		207	if (1) { no strict qw{refs};
	23					59
	23					5169
	2271					3601
1299	2271					5612	$expectation->is(q{exp})->at($text);
1300	2271	50		2271		24676	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::exp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2271					4689
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	2271	50				10760	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	2271					5985	$item{q{exp}} = $_tok;
1319	2271					4704	push @item, $_tok;
1320
1321							}
1322
1323
1324
1325	2271					3589	$repcount++;
1326
1327	2271					4174	my $savetext = $text;
1328	2271					3631	my $backtrack;
1329
1330							# MATCH (OP RIGHTARG)(s)
1331	2271					5459	while ($repcount < 100000000)
1332							{
1333	2922					4486	$backtrack = 0;
1334
1335	2922	50				6606	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		179	if (1) { no strict qw{refs};
	23					48
	23					5087
	2922					4427
1341	2922					10507	$expectation->is(q{mult_op})->at($text);
1342	2922	100		2922		36547	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::mult_op($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2922					6245
1343							{
1344
1345	2271	50				5103	Parse::RecDescent::_trace(q{<>},
1346							Parse::RecDescent::_tracefirst($text),
1347							q{multiplication},
1348							$tracelevel)
1349							if defined $::RD_TRACE;
1350	2271					6572	$expectation->failed();
1351	2271					24015	last;
1352							}
1353	651	50				3147	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	651					2035	$item{q{mult_op}} = $_tok;
1361	651					1430	push @item, $_tok;
1362
1363							}
1364
1365	651					1341	$backtrack=1;
1366
1367
1368	651	50				1655	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		160	if (1) { no strict qw{refs};
	23					53
	23					22586
	651					1133
1374	651					2104	$expectation->is(q{exp})->at($text);
1375	651	50		651		7638	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::exp($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	651					1426
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	651	50				3067	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	651					1770	$item{q{exp}} = $_tok;
1394	651					1477	push @item, $_tok;
1395
1396							}
1397
1398	651					1258	$savetext = $text;
1399	651					1895	$repcount++;
1400							}
1401	2271					8849	$text = $savetext;
1402	2271	50				6743	pop @item if $backtrack;
1403
1404	2271	50				5170	unless (@item) { undef $_tok; last }
	0					0
	0					0
1405	2271					5721	$_tok = [ @item ];
1406
1407	2271					6215	last;
1408							} # end of OPLOOP
1409
1410	2271	50				5963	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	2271	50				5097	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	2271		50			8313	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
1428
1429	2271	50				5042	Parse::RecDescent::_trace(q{Trying action},
1430							Parse::RecDescent::_tracefirst($text),
1431							q{multiplication},
1432							$tracelevel)
1433							if defined $::RD_TRACE;
1434
1435
1436	2271	50				8550	$_tok = ($_noactions) ? 0 : do {
1437							#warn 'multiplication '
1438							# if $Math::Symbolic::Parser::DEBUG;
1439	2271	100				3543	if (@{$item[1]} == 1) {
	2271					6862
1440	1650					3717	$item[1][0]
1441							}
1442							else {
1443	621					1268	my @it = @{$item[1]};
	621					2008
1444	621					1506	my $tree = shift @it;
1445	621					1795	while (@it) {
1446	651					4227	$tree = Math::Symbolic::Operator->new(
1447							shift(@it), $tree, shift(@it)
1448							);
1449							}
1450	621					1732	$tree;
1451							}
1452							};
1453	2271	50				5898	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	2271	50				5198	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1460							. $_tok . q{])},
1461							Parse::RecDescent::_tracefirst($text))
1462							if defined $::RD_TRACE;
1463	2271					4381	push @item, $_tok;
1464	2271					4790	$item{__ACTION1__}=$_tok;
1465
1466
1467	2271	50				4891	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	2271					3657	$_matched = 1;
1476	2271					4496	last;
1477							}
1478
1479
1480	2271	50	33			5889	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	2271	50	33			8877	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	2271					3796	splice @{$thisparser->{errors}}, $err_at;
	2271					6350
1501	2271	50				7144	$return = $item[$#item] unless defined $return;
1502	2271	50				5256	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	2271					4870	$_[1] = $text;
1515	2271					20991	return $return;
1516							}
1517
1518							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1519							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::parse
1520							{
1521	356			356		28037	my $thisparser = $_[0];
1522	23			23		253	use vars q{$tracelevel};
	23					75
	23					10741
1523	356		100			2246	local $tracelevel = ($tracelevel\|\|0)+1;
1524	356					769	$ERRORS = 0;
1525	356					1115	my $thisrule = $thisparser->{"rules"}{"parse"};
1526
1527	356	50				1181	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	356					738	my $err_at = @{$thisparser->{errors}};
	356					961
1535
1536	356					1195	my $score;
1537							my $score_return;
1538	356					0	my $_tok;
1539	356					849	my $return = undef;
1540	356					695	my $_matched=0;
1541	356					670	my $commit=0;
1542	356					725	my @item = ();
1543	356					1041	my %item = ();
1544	356					764	my $repeating = $_[2];
1545	356					697	my $_noactions = $_[3];
1546	356	50				1084	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	356					695
	356					993
1547	356					2314	my $_itempos = $_[5];
1548	356	50				1266	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1549	356					1151	my $text;
1550							my $lastsep;
1551	356					0	my $current_match;
1552	356					1731	my $expectation = new Parse::RecDescent::Expectation(q{expr, or //});
1553	356					4571	$expectation->at($_[1]);
1554
1555	356					2080	my $thisline;
1556	356					3303	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1557
1558
1559
1560	356		33			4307	while (!$_matched && !$commit)
1561							{
1562
1563	356	50				982	Parse::RecDescent::_trace(q{Trying production: [expr /^\\Z/]},
1564							Parse::RecDescent::_tracefirst($_[1]),
1565							q{parse},
1566							$tracelevel)
1567							if defined $::RD_TRACE;
1568	356					1302	my $thisprod = $thisrule->{"prods"}[0];
1569	356					791	$text = $_[1];
1570	356					637	my $_savetext;
1571	356					882	@item = (q{parse});
1572	356					1237	%item = (__RULE__ => q{parse});
1573	356					703	my $repcount = 0;
1574
1575
1576	356	50				992	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		192	if (1) { no strict qw{refs};
	23					64
	23					30827
	356					1344
1582	356					1291	$expectation->is(q{})->at($text);
1583	356	50		356		4602	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	356					926
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	356	50				4837	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	356					1107	$item{q{expr}} = $_tok;
1602	356					765	push @item, $_tok;
1603
1604							}
1605
1606	356	50				876	Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
1607							q{parse},
1608							$tracelevel)
1609							if defined $::RD_TRACE;
1610	356					771	undef $lastsep;
1611	356					1289	$expectation->is(q{/^\\Z/})->at($text);
1612
1613
1614	356	50	66			6143	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:^\Z)/)
	356	100				3309
1615							{
1616	1	50				6	$text = $lastsep . $text if defined $lastsep;
1617	1					5	$expectation->failed();
1618	1	50				12	Parse::RecDescent::_trace(q{<>},
1619							Parse::RecDescent::_tracefirst($text))
1620							if defined $::RD_TRACE;
1621
1622	1					3	last;
1623							}
1624	355					2228	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1625	355					1139	substr($text,0,length($current_match),q{});
1626	355	50				941	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1627							. $current_match . q{])},
1628							Parse::RecDescent::_tracefirst($text))
1629							if defined $::RD_TRACE;
1630	355					1269	push @item, $item{__PATTERN1__}=$current_match;
1631
1632
1633	355	50				952	Parse::RecDescent::_trace(q{Trying action},
1634							Parse::RecDescent::_tracefirst($text),
1635							q{parse},
1636							$tracelevel)
1637							if defined $::RD_TRACE;
1638
1639
1640	355	50				875	$_tok = ($_noactions) ? 0 : do {
1641	355					861	$return = $item[1]
1642							};
1643	355	50				937	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	355	50				868	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1650							. $_tok . q{])},
1651							Parse::RecDescent::_tracefirst($text))
1652							if defined $::RD_TRACE;
1653	355					666	push @item, $_tok;
1654	355					790	$item{__ACTION1__}=$_tok;
1655
1656
1657	355	50				884	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	355					683	$_matched = 1;
1666	355					783	last;
1667							}
1668
1669
1670	356		66			1162	while (!$_matched && !$commit)
1671							{
1672
1673	1	50				5	Parse::RecDescent::_trace(q{Trying production: [//]},
1674							Parse::RecDescent::_tracefirst($_[1]),
1675							q{parse},
1676							$tracelevel)
1677							if defined $::RD_TRACE;
1678	1					3	my $thisprod = $thisrule->{"prods"}[1];
1679	1					3	$text = $_[1];
1680	1					3	my $_savetext;
1681	1					3	@item = (q{parse});
1682	1					5	%item = (__RULE__ => q{parse});
1683	1					3	my $repcount = 0;
1684
1685
1686	1	50				4	Parse::RecDescent::_trace(q{Trying terminal: [//]}, Parse::RecDescent::_tracefirst($text),
1687							q{parse},
1688							$tracelevel)
1689							if defined $::RD_TRACE;
1690	1					3	undef $lastsep;
1691	1					3	$expectation->is(q{})->at($text);
1692
1693
1694	1	50	33			81	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:)/)
	1	50				16
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					9	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1705	1					3	substr($text,0,length($current_match),q{});
1706	1	50				4	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1707							. $current_match . q{])},
1708							Parse::RecDescent::_tracefirst($text))
1709							if defined $::RD_TRACE;
1710	1					6	push @item, $item{__PATTERN1__}=$current_match;
1711
1712
1713	1	50				4	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					3
1721	1	50				6	unless (defined $_tok)
1722							{
1723	1	50				4	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1724							if defined $::RD_TRACE;
1725	1					3	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	356	100	66			1153	unless ( $_matched \|\| defined($score) )
1749							{
1750
1751
1752	1					17	$_[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					13	return undef;
1759							}
1760	355	50	33			1155	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	355					649	splice @{$thisparser->{errors}}, $err_at;
	355					881
1769	355	50				881	$return = $item[$#item] unless defined $return;
1770	355	50				885	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	355					906	$_[1] = $text;
1783	355					3249	return $return;
1784							}
1785
1786							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
1787							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::addition
1788							{
1789	1779			1779		3505	my $thisparser = $_[0];
1790	23			23		205	use vars q{$tracelevel};
	23					57
	23					10854
1791	1779		50			5125	local $tracelevel = ($tracelevel\|\|0)+1;
1792	1779					2930	$ERRORS = 0;
1793	1779					4830	my $thisrule = $thisparser->{"rules"}{"addition"};
1794
1795	1779	50				4041	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	1779					2824	my $err_at = @{$thisparser->{errors}};
	1779					4209
1803
1804	1779					5050	my $score;
1805							my $score_return;
1806	1779					0	my $_tok;
1807	1779					3118	my $return = undef;
1808	1779					3104	my $_matched=0;
1809	1779					3160	my $commit=0;
1810	1779					3356	my @item = ();
1811	1779					3163	my %item = ();
1812	1779					2903	my $repeating = $_[2];
1813	1779					3160	my $_noactions = $_[3];
1814	1779	50				4329	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	1779					2846
	1779					4026
1815	1779					3078	my $_itempos = $_[5];
1816	1779	50				4876	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1817	1779					5416	my $text;
1818							my $lastsep;
1819	1779					0	my $current_match;
1820	1779					5313	my $expectation = new Parse::RecDescent::Expectation(q{});
1821	1779					14938	$expectation->at($_[1]);
1822
1823	1779					7746	my $thisline;
1824	1779					6015	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1825
1826
1827
1828	1779		33			16046	while (!$_matched && !$commit)
1829							{
1830
1831	1779	50				4004	Parse::RecDescent::_trace(q{Trying production: []},
1832							Parse::RecDescent::_tracefirst($_[1]),
1833							q{addition},
1834							$tracelevel)
1835							if defined $::RD_TRACE;
1836	1779					4718	my $thisprod = $thisrule->{"prods"}[0];
1837	1779					3314	$text = $_[1];
1838	1779					3056	my $_savetext;
1839	1779					4185	@item = (q{addition});
1840	1779					4274	%item = (__RULE__ => q{addition});
1841	1779					2907	my $repcount = 0;
1842
1843
1844	1779	50				4382	Parse::RecDescent::_trace(q{Trying operator: []},
1845							Parse::RecDescent::_tracefirst($text),
1846							q{addition},
1847							$tracelevel)
1848							if defined $::RD_TRACE;
1849	1779					4948	$expectation->is(q{})->at($text);
1850
1851	1779					13221	$_tok = undef;
1852	1779					3223	OPLOOP: while (1)
1853							{
1854	1779					3081	$repcount = 0;
1855	1779					3598	my @item;
1856							my %item;
1857
1858							# MATCH LEFTARG
1859
1860	1779	50				4101	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		219	if (1) { no strict qw{refs};
	23					48
	23					6098
	1779					2830
1866	1779					4467	$expectation->is(q{multiplication})->at($text);
1867	1779	50		1779		18550	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::multiplication($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	1779					6010
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	1779	50				8072	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	1779					4365	$item{q{multiplication}} = $_tok;
1886	1779					3442	push @item, $_tok;
1887
1888							}
1889
1890
1891
1892	1779					2877	$repcount++;
1893
1894	1779					3034	my $savetext = $text;
1895	1779					2874	my $backtrack;
1896
1897							# MATCH (OP RIGHTARG)(s)
1898	1779					4517	while ($repcount < 100000000)
1899							{
1900	2271					3781	$backtrack = 0;
1901
1902	2271	50				5461	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		211	if (1) { no strict qw{refs};
	23					74
	23					5005
	2271					3453
1908	2271					7503	$expectation->is(q{add_op})->at($text);
1909	2271	100		2271		31224	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::add_op($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	2271					5097
1910							{
1911
1912	1779	50				4183	Parse::RecDescent::_trace(q{<>},
1913							Parse::RecDescent::_tracefirst($text),
1914							q{addition},
1915							$tracelevel)
1916							if defined $::RD_TRACE;
1917	1779					5230	$expectation->failed();
1918	1779					16345	last;
1919							}
1920	492	50				2465	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	492					1443	$item{q{add_op}} = $_tok;
1928	492					1225	push @item, $_tok;
1929
1930							}
1931
1932	492					954	$backtrack=1;
1933
1934
1935	492	50				1229	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		178	if (1) { no strict qw{refs};
	23					60
	23					21184
	492					990
1941	492					1778	$expectation->is(q{multiplication})->at($text);
1942	492	50		492		5952	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::multiplication($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	492					1205
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	492	50				2408	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	492					1382	$item{q{multiplication}} = $_tok;
1961	492					1116	push @item, $_tok;
1962
1963							}
1964
1965	492					934	$savetext = $text;
1966	492					1402	$repcount++;
1967							}
1968	1779					6694	$text = $savetext;
1969	1779	50				4328	pop @item if $backtrack;
1970
1971	1779	50				4090	unless (@item) { undef $_tok; last }
	0					0
	0					0
1972	1779					4366	$_tok = [ @item ];
1973
1974	1779					4672	last;
1975							} # end of OPLOOP
1976
1977	1779	50				4859	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	1779	50				3986	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	1779		50			6554	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
1995
1996	1779	50				4150	Parse::RecDescent::_trace(q{Trying action},
1997							Parse::RecDescent::_tracefirst($text),
1998							q{addition},
1999							$tracelevel)
2000							if defined $::RD_TRACE;
2001
2002
2003	1779	50				4561	$_tok = ($_noactions) ? 0 : do {
2004							#warn 'addition '
2005							# if $Math::Symbolic::Parser::DEBUG;
2006	1779	100				5828	if (@{$item[1]} == 1) {
	1779					5033
2007	1363					3351	$item[1][0]
2008							}
2009							else {
2010	416					770	my @it = @{$item[1]};
	416					2901
2011	416					919	my $tree = shift @it;
2012	416					1358	while (@it) {
2013	492					3071	$tree = Math::Symbolic::Operator->new(
2014							shift(@it), $tree, shift(@it)
2015							);
2016							}
2017	416					1192	$tree;
2018							}
2019							};
2020	1779	50				4319	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	1779	50				3901	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2027							. $_tok . q{])},
2028							Parse::RecDescent::_tracefirst($text))
2029							if defined $::RD_TRACE;
2030	1779					6975	push @item, $_tok;
2031	1779					3636	$item{__ACTION1__}=$_tok;
2032
2033
2034	1779	50				3912	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	1779					3120	$_matched = 1;
2043	1779					3761	last;
2044							}
2045
2046
2047	1779	50	33			4762	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	1779	50	33			7178	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	1779					6978	splice @{$thisparser->{errors}}, $err_at;
	1779					4787
2068	1779	50				5127	$return = $item[$#item] unless defined $return;
2069	1779	50				4471	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	1779					3642	$_[1] = $text;
2082	1779					15170	return $return;
2083							}
2084
2085							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
2086							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::factor
2087							{
2088	6123			6123		11260	my $thisparser = $_[0];
2089	23			23		192	use vars q{$tracelevel};
	23					69
	23					14442
2090	6123		50			15465	local $tracelevel = ($tracelevel\|\|0)+1;
2091	6123					11456	$ERRORS = 0;
2092	6123					15356	my $thisrule = $thisparser->{"rules"}{"factor"};
2093
2094	6123	50				13089	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	6123					9075	my $err_at = @{$thisparser->{errors}};
	6123					12814
2102
2103	6123					15479	my $score;
2104							my $score_return;
2105	6123					0	my $_tok;
2106	6123					9699	my $return = undef;
2107	6123					9213	my $_matched=0;
2108	6123					9599	my $commit=0;
2109	6123					10845	my @item = ();
2110	6123					14486	my %item = ();
2111	6123					9580	my $repeating = $_[2];
2112	6123					9676	my $_noactions = $_[3];
2113	6123	50				13312	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	6123					9771
	6123					12240
2114	6123					10159	my $_itempos = $_[5];
2115	6123	50				14923	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2116	6123					19595	my $text;
2117							my $lastsep;
2118	6123					0	my $current_match;
2119	6123					23015	my $expectation = new Parse::RecDescent::Expectation(q{/(?:\\+\|-)*/});
2120	6123					54914	$expectation->at($_[1]);
2121
2122	6123					26631	my $thisline;
2123	6123					25133	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2124
2125
2126
2127	6123		33			53790	while (!$_matched && !$commit)
2128							{
2129
2130	6123	50				13018	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ number]},
2131							Parse::RecDescent::_tracefirst($_[1]),
2132							q{factor},
2133							$tracelevel)
2134							if defined $::RD_TRACE;
2135	6123					15878	my $thisprod = $thisrule->{"prods"}[0];
2136	6123					10330	$text = $_[1];
2137	6123					9207	my $_savetext;
2138	6123					15217	@item = (q{factor});
2139	6123					13943	%item = (__RULE__ => q{factor});
2140	6123					9700	my $repcount = 0;
2141
2142
2143	6123	50				13135	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2144							q{factor},
2145							$tracelevel)
2146							if defined $::RD_TRACE;
2147	6123					10548	undef $lastsep;
2148	6123					14870	$expectation->is(q{})->at($text);
2149
2150
2151	6123	50	33			92467	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	6123	50				60091
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	6123					33098	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2162	6123					17662	substr($text,0,length($current_match),q{});
2163	6123	50				13658	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2164							. $current_match . q{])},
2165							Parse::RecDescent::_tracefirst($text))
2166							if defined $::RD_TRACE;
2167	6123					17532	push @item, $item{__PATTERN1__}=$current_match;
2168
2169
2170	6123	50				12826	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		185	if (1) { no strict qw{refs};
	23					50
	23					18578
	6123					9585
2176	6123					15207	$expectation->is(q{number})->at($text);
2177	6123	100		6123		69934	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::number($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	6123					12464
2178							{
2179
2180	4325	50				10502	Parse::RecDescent::_trace(q{<>},
2181							Parse::RecDescent::_tracefirst($text),
2182							q{factor},
2183							$tracelevel)
2184							if defined $::RD_TRACE;
2185	4325					12502	$expectation->failed();
2186	4325					48886	last;
2187							}
2188	1798	50				9741	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	1798					4591	$item{q{number}} = $_tok;
2196	1798					3572	push @item, $_tok;
2197
2198							}
2199
2200	1798	50				3965	Parse::RecDescent::_trace(q{Trying action},
2201							Parse::RecDescent::_tracefirst($text),
2202							q{factor},
2203							$tracelevel)
2204							if defined $::RD_TRACE;
2205
2206
2207	1798	50				3767	$_tok = ($_noactions) ? 0 : do {
2208							#warn 'unary_n '
2209							# if $Math::Symbolic::Parser::DEBUG;
2210	1798	100				4005	if ($item[1]) {
2211	146					482	my @it = split //, $item[1];
2212	146					284	my $ret = $item[2];
2213	146					378	foreach (grep {$_ eq '-'} @it) {
	146					644
2214	146					713	$ret = Math::Symbolic::Operator->new('neg',$ret);
2215							}
2216							$ret
2217	146					370	}
2218							else {
2219	1652					3326	$item[2]
2220							}
2221							};
2222	1798	50				4270	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	1798	50				3768	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2229							. $_tok . q{])},
2230							Parse::RecDescent::_tracefirst($text))
2231							if defined $::RD_TRACE;
2232	1798					3886	push @item, $_tok;
2233	1798					5179	$item{__ACTION1__}=$_tok;
2234
2235
2236	1798	50				4144	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	1798					2918	$_matched = 1;
2245	1798					3553	last;
2246							}
2247
2248
2249	6123		66			29468	while (!$_matched && !$commit)
2250							{
2251
2252	4325	50				9503	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ function]},
2253							Parse::RecDescent::_tracefirst($_[1]),
2254							q{factor},
2255							$tracelevel)
2256							if defined $::RD_TRACE;
2257	4325					10353	my $thisprod = $thisrule->{"prods"}[1];
2258	4325					9063	$text = $_[1];
2259	4325					6655	my $_savetext;
2260	4325					10995	@item = (q{factor});
2261	4325					12391	%item = (__RULE__ => q{factor});
2262	4325					6733	my $repcount = 0;
2263
2264
2265	4325	50				8795	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2266							q{factor},
2267							$tracelevel)
2268							if defined $::RD_TRACE;
2269	4325					6776	undef $lastsep;
2270	4325					11287	$expectation->is(q{})->at($text);
2271
2272
2273	4325	50	33			58735	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	4325	50				32768
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	4325					22444	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2284	4325					11876	substr($text,0,length($current_match),q{});
2285	4325	50				10815	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2286							. $current_match . q{])},
2287							Parse::RecDescent::_tracefirst($text))
2288							if defined $::RD_TRACE;
2289	4325					12022	push @item, $item{__PATTERN1__}=$current_match;
2290
2291
2292	4325	50				9445	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		209	if (1) { no strict qw{refs};
	23					49
	23					18269
	4325					6453
2298	4325					14381	$expectation->is(q{function})->at($text);
2299	4325	100		4325		45328	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::function($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	4325					8912
2300							{
2301
2302	3835	50				7976	Parse::RecDescent::_trace(q{<>},
2303							Parse::RecDescent::_tracefirst($text),
2304							q{factor},
2305							$tracelevel)
2306							if defined $::RD_TRACE;
2307	3835					19419	$expectation->failed();
2308	3835					30259	last;
2309							}
2310	490	50				2570	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					1467	$item{q{function}} = $_tok;
2318	490					1184	push @item, $_tok;
2319
2320							}
2321
2322	490	50				1326	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				1168	$_tok = ($_noactions) ? 0 : do {
2330							#warn 'unary_f '
2331							# if $Math::Symbolic::Parser::DEBUG;
2332	490	50				1223	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					1061	$item[2]
2342							}
2343							};
2344	490	50				1946	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				1344	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2351							. $_tok . q{])},
2352							Parse::RecDescent::_tracefirst($text))
2353							if defined $::RD_TRACE;
2354	490					1047	push @item, $_tok;
2355	490					1243	$item{__ACTION1__}=$_tok;
2356
2357
2358	490	50				1226	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					871	$_matched = 1;
2367	490					985	last;
2368							}
2369
2370
2371	6123		66			25428	while (!$_matched && !$commit)
2372							{
2373
2374	3835	50				9183	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ variable]},
2375							Parse::RecDescent::_tracefirst($_[1]),
2376							q{factor},
2377							$tracelevel)
2378							if defined $::RD_TRACE;
2379	3835					16050	my $thisprod = $thisrule->{"prods"}[2];
2380	3835					7484	$text = $_[1];
2381	3835					5722	my $_savetext;
2382	3835					9998	@item = (q{factor});
2383	3835					10704	%item = (__RULE__ => q{factor});
2384	3835					6095	my $repcount = 0;
2385
2386
2387	3835	50				8094	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2388							q{factor},
2389							$tracelevel)
2390							if defined $::RD_TRACE;
2391	3835					6284	undef $lastsep;
2392	3835					9327	$expectation->is(q{})->at($text);
2393
2394
2395	3835	50	33			50003	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	3835	50				28901
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	3835					21237	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2406	3835					14504	substr($text,0,length($current_match),q{});
2407	3835	50				7794	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2408							. $current_match . q{])},
2409							Parse::RecDescent::_tracefirst($text))
2410							if defined $::RD_TRACE;
2411	3835					11099	push @item, $item{__PATTERN1__}=$current_match;
2412
2413
2414	3835	50				10445	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		196	if (1) { no strict qw{refs};
	23					53
	23					23413
	3835					6290
2420	3835					9264	$expectation->is(q{variable})->at($text);
2421	3835	100		3835		50595	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::variable($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	3835					8682
2422							{
2423
2424	631	50				1595	Parse::RecDescent::_trace(q{<>},
2425							Parse::RecDescent::_tracefirst($text),
2426							q{factor},
2427							$tracelevel)
2428							if defined $::RD_TRACE;
2429	631					1974	$expectation->failed();
2430	631					5034	last;
2431							}
2432	3204	50				15668	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	3204					7381	$item{q{variable}} = $_tok;
2440	3204					6160	push @item, $_tok;
2441
2442							}
2443
2444	3204	50				7315	Parse::RecDescent::_trace(q{Trying action},
2445							Parse::RecDescent::_tracefirst($text),
2446							q{factor},
2447							$tracelevel)
2448							if defined $::RD_TRACE;
2449
2450
2451	3204	50				6330	$_tok = ($_noactions) ? 0 : do {
2452							#warn 'unary_v '
2453							# if $Math::Symbolic::Parser::DEBUG;
2454	3204	100				6485	if ($item[1]) {
2455	22					69	my @it = split //, $item[1];
2456	22					38	my $ret = $item[2];
2457	22					56	foreach (grep {$_ eq '-'} @it) {
	22					82
2458	22					139	$ret = Math::Symbolic::Operator->new('neg',$ret);
2459							}
2460							$ret
2461	22					55	}
2462							else {
2463	3182					5996	$item[2]
2464							}
2465							};
2466	3204	50				7261	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	3204	50				6297	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2473							. $_tok . q{])},
2474							Parse::RecDescent::_tracefirst($text))
2475							if defined $::RD_TRACE;
2476	3204					8429	push @item, $_tok;
2477	3204					6625	$item{__ACTION1__}=$_tok;
2478
2479
2480	3204	50				6392	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	3204					4892	$_matched = 1;
2489	3204					6005	last;
2490							}
2491
2492
2493	6123		66			17637	while (!$_matched && !$commit)
2494							{
2495
2496	631	50				1568	Parse::RecDescent::_trace(q{Trying production: [/(?:\\+\|-)*/ '(' expr ')']},
2497							Parse::RecDescent::_tracefirst($_[1]),
2498							q{factor},
2499							$tracelevel)
2500							if defined $::RD_TRACE;
2501	631					1580	my $thisprod = $thisrule->{"prods"}[3];
2502	631					1296	$text = $_[1];
2503	631					1026	my $_savetext;
2504	631					1739	@item = (q{factor});
2505	631					1960	%item = (__RULE__ => q{factor});
2506	631					1093	my $repcount = 0;
2507
2508
2509	631	50				1705	Parse::RecDescent::_trace(q{Trying terminal: [/(?:\\+\|-)*/]}, Parse::RecDescent::_tracefirst($text),
2510							q{factor},
2511							$tracelevel)
2512							if defined $::RD_TRACE;
2513	631					1140	undef $lastsep;
2514	631					1677	$expectation->is(q{})->at($text);
2515
2516
2517	631	50	33			8225	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(?:\+\|-)*)/)
	631	50				5440
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	631					3440	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2528	631					1950	substr($text,0,length($current_match),q{});
2529	631	50				1565	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2530							. $current_match . q{])},
2531							Parse::RecDescent::_tracefirst($text))
2532							if defined $::RD_TRACE;
2533	631					2045	push @item, $item{__PATTERN1__}=$current_match;
2534
2535
2536	631	50				1469	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
2537							Parse::RecDescent::_tracefirst($text),
2538							q{factor},
2539							$tracelevel)
2540							if defined $::RD_TRACE;
2541	631					1024	undef $lastsep;
2542	631					1621	$expectation->is(q{'('})->at($text);
2543
2544
2545	631	50	33			7164	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	631	50				5458
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	631					2834	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2556	631					1718	substr($text,0,length($current_match),q{});
2557	631	50				1670	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2558							. $current_match . q{])},
2559							Parse::RecDescent::_tracefirst($text))
2560							if defined $::RD_TRACE;
2561	631					1881	push @item, $item{__STRING1__}=$current_match;
2562
2563
2564	631	50				1553	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		198	if (1) { no strict qw{refs};
	23					53
	23					28439
	631					957
2570	631					1721	$expectation->is(q{expr})->at($text);
2571	631	50		631		7638	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	631					1513
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	631	50				2862	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	631					1927	$item{q{expr}} = $_tok;
2590	631					1333	push @item, $_tok;
2591
2592							}
2593
2594	631	50				1617	Parse::RecDescent::_trace(q{Trying terminal: [')']},
2595							Parse::RecDescent::_tracefirst($text),
2596							q{factor},
2597							$tracelevel)
2598							if defined $::RD_TRACE;
2599	631					1251	undef $lastsep;
2600	631					2276	$expectation->is(q{')'})->at($text);
2601
2602
2603	631	50	33			9583	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	631	50				6337
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	631					3908	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2614	631					2131	substr($text,0,length($current_match),q{});
2615	631	50				1618	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2616							. $current_match . q{])},
2617							Parse::RecDescent::_tracefirst($text))
2618							if defined $::RD_TRACE;
2619	631					2089	push @item, $item{__STRING2__}=$current_match;
2620
2621
2622	631	50				1875	Parse::RecDescent::_trace(q{Trying action},
2623							Parse::RecDescent::_tracefirst($text),
2624							q{factor},
2625							$tracelevel)
2626							if defined $::RD_TRACE;
2627
2628
2629	631	50				1601	$_tok = ($_noactions) ? 0 : do {
2630							#warn 'unary_expr '
2631							# if $Math::Symbolic::Parser::DEBUG;
2632	631	100				1695	if ($item[1]) {
2633	4					14	my @it = split //, $item[1];
2634	4					6	my $ret = $item[3];
2635	4					13	foreach (grep {$_ eq '-'} @it) {
	10					23
2636	10					31	$ret = Math::Symbolic::Operator->new('neg',$ret);
2637							}
2638							$ret
2639	4					12	}
2640							else {
2641	627					1363	$item[3]
2642							}
2643							};
2644	631	50				1606	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	631	50				1540	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2651							. $_tok . q{])},
2652							Parse::RecDescent::_tracefirst($text))
2653							if defined $::RD_TRACE;
2654	631					1219	push @item, $_tok;
2655	631					1521	$item{__ACTION1__}=$_tok;
2656
2657
2658	631	50				1474	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	631					1429	$_matched = 1;
2667	631					1410	last;
2668							}
2669
2670
2671	6123	50	33			14798	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	6123	50	33			21958	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	6123					9360	splice @{$thisparser->{errors}}, $err_at;
	6123					13881
2692	6123	50				15472	$return = $item[$#item] unless defined $return;
2693	6123	50				13426	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	6123					12832	$_[1] = $text;
2706	6123					51173	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		310	my $thisparser = $_[0];
2713	23			23		203	use vars q{$tracelevel};
	23					53
	23					43618
2714	159		50			427	local $tracelevel = ($tracelevel\|\|0)+1;
2715	159					269	$ERRORS = 0;
2716	159					427	my $thisrule = $thisparser->{"rules"}{"identifier_list"};
2717
2718	159	50				332	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					220	my $err_at = @{$thisparser->{errors}};
	159					361
2726
2727	159					403	my $score;
2728							my $score_return;
2729	159					0	my $_tok;
2730	159					250	my $return = undef;
2731	159					238	my $_matched=0;
2732	159					245	my $commit=0;
2733	159					262	my @item = ();
2734	159					277	my %item = ();
2735	159					245	my $repeating = $_[2];
2736	159					245	my $_noactions = $_[3];
2737	159	50				360	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	159					229
	159					293
2738	159					309	my $_itempos = $_[5];
2739	159	50				458	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2740	159					366	my $text;
2741							my $lastsep;
2742	159					0	my $current_match;
2743	159					565	my $expectation = new Parse::RecDescent::Expectation(q{});
2744	159					1579	$expectation->at($_[1]);
2745
2746	159					704	my $thisline;
2747	159					628	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2748
2749
2750
2751	159		33			1417	while (!$_matched && !$commit)
2752							{
2753
2754	159	50				354	Parse::RecDescent::_trace(q{Trying production: []},
2755							Parse::RecDescent::_tracefirst($_[1]),
2756							q{identifier_list},
2757							$tracelevel)
2758							if defined $::RD_TRACE;
2759	159					409	my $thisprod = $thisrule->{"prods"}[0];
2760	159					314	$text = $_[1];
2761	159					262	my $_savetext;
2762	159					418	@item = (q{identifier_list});
2763	159					352	%item = (__RULE__ => q{identifier_list});
2764	159					234	my $repcount = 0;
2765
2766
2767	159	50				369	Parse::RecDescent::_trace(q{Trying operator: []},
2768							Parse::RecDescent::_tracefirst($text),
2769							q{identifier_list},
2770							$tracelevel)
2771							if defined $::RD_TRACE;
2772	159					438	$expectation->is(q{})->at($text);
2773
2774	159					1109	$_tok = undef;
2775	159					235	OPLOOP: while (1)
2776							{
2777	159					234	$repcount = 0;
2778	159					296	my @item;
2779							my %item;
2780
2781							# MATCH LEFTARG
2782
2783	159	50				352	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					266	undef $lastsep;
2788	159					385	$expectation->is(q{/[a-zA-Z][a-zA-Z0-9_]*/})->at($text);
2789
2790
2791	159	50	33			2150	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	159	50				1419
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					805	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2802	159					409	substr($text,0,length($current_match),q{});
2803	159	50				422	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2804							. $current_match . q{])},
2805							Parse::RecDescent::_tracefirst($text))
2806							if defined $::RD_TRACE;
2807	159					413	push @item, $item{__PATTERN1__}=$current_match;
2808
2809
2810
2811
2812	159					254	$repcount++;
2813
2814	159					271	my $savetext = $text;
2815	159					250	my $backtrack;
2816
2817							# MATCH (OP RIGHTARG)(s)
2818	159					401	while ($repcount < 100000000)
2819							{
2820	233					375	$backtrack = 0;
2821
2822	233	50				491	Parse::RecDescent::_trace(q{Trying terminal: [',']},
2823							Parse::RecDescent::_tracefirst($text),
2824							q{identifier_list},
2825							$tracelevel)
2826							if defined $::RD_TRACE;
2827	233					355	undef $lastsep;
2828	233					635	$expectation->is(q{','})->at($text);
2829
2830
2831	233	50	66			2718	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\,/)
	233	100				1844
2832							{
2833	159	50				442	$text = $lastsep . $text if defined $lastsep;
2834
2835	159					532	$expectation->failed();
2836	159	50				1471	Parse::RecDescent::_trace(qq{<>},
2837							Parse::RecDescent::_tracefirst($text))
2838							if defined $::RD_TRACE;
2839	159					316	last;
2840							}
2841	74					417	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2842	74					188	substr($text,0,length($current_match),q{});
2843	74	50				171	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2844							. $current_match . q{])},
2845							Parse::RecDescent::_tracefirst($text))
2846							if defined $::RD_TRACE;
2847	74					211	push @item, $item{__STRING1__}=$current_match;
2848
2849
2850	74					140	pop @item;
2851
2852
2853	74	50				217	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					152	undef $lastsep;
2858	74					207	$expectation->is(q{/[a-zA-Z][a-zA-Z0-9_]*/})->at($text);
2859
2860
2861	74	50	33			938	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[a-zA-Z][a-zA-Z0-9_]*)/)
	74	50				601
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					338	$current_match = substr($text, $-[0], $+[0] - $-[0]);
2872	74					210	substr($text,0,length($current_match),q{});
2873	74	50				169	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2874							. $current_match . q{])},
2875							Parse::RecDescent::_tracefirst($text))
2876							if defined $::RD_TRACE;
2877	74					178	push @item, $item{__PATTERN2__}=$current_match;
2878
2879
2880	74					123	$savetext = $text;
2881	74					179	$repcount++;
2882							}
2883	159					365	$text = $savetext;
2884	159	50				329	pop @item if $backtrack;
2885
2886	159	50				360	unless (@item) { undef $_tok; last }
	0					0
	0					0
2887	159					452	$_tok = [ @item ];
2888
2889	159					481	last;
2890							} # end of OPLOOP
2891
2892	159	50				380	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				392	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			637	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
2910
2911	159	50				315	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				313	$_tok = ($_noactions) ? 0 : do {
2919							#warn 'identifier_list '
2920							# if $Math::Symbolic::Parser::DEBUG;
2921	159					311	$item[1]
2922							};
2923	159	50				329	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				4363	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2930							. $_tok . q{])},
2931							Parse::RecDescent::_tracefirst($text))
2932							if defined $::RD_TRACE;
2933	159					296	push @item, $_tok;
2934	159					380	$item{__ACTION1__}=$_tok;
2935
2936
2937	159	50				332	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					271	$_matched = 1;
2946	159					350	last;
2947							}
2948
2949
2950	159	50	33			412	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			704	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					238	splice @{$thisparser->{errors}}, $err_at;
	159					447
2971	159	50				405	$return = $item[$#item] unless defined $return;
2972	159	50				327	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					320	$_[1] = $text;
2985	159					1351	return $return;
2986							}
2987
2988							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args, $_itempos)
2989							sub Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr
2990							{
2991	1779			1779		3727	my $thisparser = $_[0];
2992	23			23		204	use vars q{$tracelevel};
	23					53
	23					9555
2993	1779		50			5575	local $tracelevel = ($tracelevel\|\|0)+1;
2994	1779					3073	$ERRORS = 0;
2995	1779					5447	my $thisrule = $thisparser->{"rules"}{"expr"};
2996
2997	1779	50				4227	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	1779					3121	my $err_at = @{$thisparser->{errors}};
	1779					4233
3005
3006	1779					5128	my $score;
3007							my $score_return;
3008	1779					0	my $_tok;
3009	1779					2982	my $return = undef;
3010	1779					3215	my $_matched=0;
3011	1779					2712	my $commit=0;
3012	1779					3210	my @item = ();
3013	1779					3307	my %item = ();
3014	1779					2863	my $repeating = $_[2];
3015	1779					3031	my $_noactions = $_[3];
3016	1779	50				4576	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	1779					2889
	1779					7712
3017	1779					3526	my $_itempos = $_[5];
3018	1779	50				4962	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3019	1779					4585	my $text;
3020							my $lastsep;
3021	1779					0	my $current_match;
3022	1779					6043	my $expectation = new Parse::RecDescent::Expectation(q{addition});
3023	1779					16156	$expectation->at($_[1]);
3024
3025	1779					8418	my $thisline;
3026	1779					7429	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3027
3028
3029
3030	1779		33			16524	while (!$_matched && !$commit)
3031							{
3032
3033	1779	50				4270	Parse::RecDescent::_trace(q{Trying production: [addition]},
3034							Parse::RecDescent::_tracefirst($_[1]),
3035							q{expr},
3036							$tracelevel)
3037							if defined $::RD_TRACE;
3038	1779					4606	my $thisprod = $thisrule->{"prods"}[0];
3039	1779					3281	$text = $_[1];
3040	1779					2776	my $_savetext;
3041	1779					4031	@item = (q{expr});
3042	1779					4408	%item = (__RULE__ => q{expr});
3043	1779					2985	my $repcount = 0;
3044
3045
3046	1779	50				4381	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		173	if (1) { no strict qw{refs};
	23					78
	23					15360
	1779					3159
3052	1779					4649	$expectation->is(q{})->at($text);
3053	1779	50		1779		21170	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::addition($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	1779					3880
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	1779	50				8117	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	1779					4620	$item{q{addition}} = $_tok;
3072	1779					3442	push @item, $_tok;
3073
3074							}
3075
3076	1779	50				3874	Parse::RecDescent::_trace(q{Trying action},
3077							Parse::RecDescent::_tracefirst($text),
3078							q{expr},
3079							$tracelevel)
3080							if defined $::RD_TRACE;
3081
3082
3083	1779	50				3792	$_tok = ($_noactions) ? 0 : do {
3084							#warn 'expr ' if $Math::Symbolic::Parser::DEBUG;
3085	1779					3383	$item[1]
3086							};
3087	1779	50				4253	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	1779	50				3977	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3094							. $_tok . q{])},
3095							Parse::RecDescent::_tracefirst($text))
3096							if defined $::RD_TRACE;
3097	1779					2955	push @item, $_tok;
3098	1779					3742	$item{__ACTION1__}=$_tok;
3099
3100
3101	1779	50				3826	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	1779					3245	$_matched = 1;
3110	1779					3653	last;
3111							}
3112
3113
3114	1779	50	33			5730	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	1779	50	33			6899	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	1779					2870	splice @{$thisparser->{errors}}, $err_at;
	1779					3887
3135	1779	50				4847	$return = $item[$#item] unless defined $return;
3136	1779	50				4037	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	1779					3867	$_[1] = $text;
3149	1779					14503	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	2922			2922		5222	my $thisparser = $_[0];
3156	23			23		223	use vars q{$tracelevel};
	23					76
	23					28925
3157	2922		50			7692	local $tracelevel = ($tracelevel\|\|0)+1;
3158	2922					5197	$ERRORS = 0;
3159	2922					7186	my $thisrule = $thisparser->{"rules"}{"mult_op"};
3160
3161	2922	50				6661	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	2922					5019	my $err_at = @{$thisparser->{errors}};
	2922					6695
3169
3170	2922					12030	my $score;
3171							my $score_return;
3172	2922					0	my $_tok;
3173	2922					4893	my $return = undef;
3174	2922					4390	my $_matched=0;
3175	2922					4393	my $commit=0;
3176	2922					5277	my @item = ();
3177	2922					4983	my %item = ();
3178	2922					4900	my $repeating = $_[2];
3179	2922					4616	my $_noactions = $_[3];
3180	2922	50				6449	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2922					4569
	2922					5652
3181	2922					5452	my $_itempos = $_[5];
3182	2922	50				8396	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3183	2922					8630	my $text;
3184							my $lastsep;
3185	2922					0	my $current_match;
3186	2922					9827	my $expectation = new Parse::RecDescent::Expectation(q{'*', or '/'});
3187	2922					29409	$expectation->at($_[1]);
3188
3189	2922					13977	my $thisline;
3190	2922					14017	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3191
3192
3193
3194	2922		33			26908	while (!$_matched && !$commit)
3195							{
3196
3197	2922	50				9566	Parse::RecDescent::_trace(q{Trying production: ['*']},
3198							Parse::RecDescent::_tracefirst($_[1]),
3199							q{mult_op},
3200							$tracelevel)
3201							if defined $::RD_TRACE;
3202	2922					7201	my $thisprod = $thisrule->{"prods"}[0];
3203	2922					5315	$text = $_[1];
3204	2922					4398	my $_savetext;
3205	2922					6127	@item = (q{mult_op});
3206	2922					7160	%item = (__RULE__ => q{mult_op});
3207	2922					5115	my $repcount = 0;
3208
3209
3210	2922	50				6835	Parse::RecDescent::_trace(q{Trying terminal: ['*']},
3211							Parse::RecDescent::_tracefirst($text),
3212							q{mult_op},
3213							$tracelevel)
3214							if defined $::RD_TRACE;
3215	2922					5537	undef $lastsep;
3216	2922					7511	$expectation->is(q{})->at($text);
3217
3218
3219	2922	50	66			42552	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\*/)
	2922	100				23688
3220							{
3221	2356	50				6502	$text = $lastsep . $text if defined $lastsep;
3222
3223	2356					7702	$expectation->failed();
3224	2356	50				10362	Parse::RecDescent::_trace(qq{<>},
3225							Parse::RecDescent::_tracefirst($text))
3226							if defined $::RD_TRACE;
3227	2356					5211	last;
3228							}
3229	566					7179	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3230	566					1889	substr($text,0,length($current_match),q{});
3231	566	50				1825	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3232							. $current_match . q{])},
3233							Parse::RecDescent::_tracefirst($text))
3234							if defined $::RD_TRACE;
3235	566					1838	push @item, $item{__STRING1__}=$current_match;
3236
3237
3238	566	50				1458	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	566					1068	$_matched = 1;
3247	566					1228	last;
3248							}
3249
3250
3251	2922		66			11105	while (!$_matched && !$commit)
3252							{
3253
3254	2356	50				5044	Parse::RecDescent::_trace(q{Trying production: ['/']},
3255							Parse::RecDescent::_tracefirst($_[1]),
3256							q{mult_op},
3257							$tracelevel)
3258							if defined $::RD_TRACE;
3259	2356					5203	my $thisprod = $thisrule->{"prods"}[1];
3260	2356					5140	$text = $_[1];
3261	2356					3476	my $_savetext;
3262	2356					5443	@item = (q{mult_op});
3263	2356					6277	%item = (__RULE__ => q{mult_op});
3264	2356					3983	my $repcount = 0;
3265
3266
3267	2356	50				5430	Parse::RecDescent::_trace(q{Trying terminal: ['/']},
3268							Parse::RecDescent::_tracefirst($text),
3269							q{mult_op},
3270							$tracelevel)
3271							if defined $::RD_TRACE;
3272	2356					4058	undef $lastsep;
3273	2356					6032	$expectation->is(q{})->at($text);
3274
3275
3276	2356	50	66			31052	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\//)
	2356	100				18483
3277							{
3278	2271	50				5855	$text = $lastsep . $text if defined $lastsep;
3279
3280	2271					6577	$expectation->failed();
3281	2271	50				8923	Parse::RecDescent::_trace(qq{<>},
3282							Parse::RecDescent::_tracefirst($text))
3283							if defined $::RD_TRACE;
3284	2271					4554	last;
3285							}
3286	85					529	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3287	85					286	substr($text,0,length($current_match),q{});
3288	85	50				334	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3289							. $current_match . q{])},
3290							Parse::RecDescent::_tracefirst($text))
3291							if defined $::RD_TRACE;
3292	85					320	push @item, $item{__STRING1__}=$current_match;
3293
3294
3295	85	50				238	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					153	$_matched = 1;
3304	85					154	last;
3305							}
3306
3307
3308	2922	100	66			10339	unless ( $_matched \|\| defined($score) )
3309							{
3310
3311
3312	2271					4223	$_[1] = $text; # NOT SURE THIS IS NEEDED
3313	2271	50				5292	Parse::RecDescent::_trace(q{<>},
3314							Parse::RecDescent::_tracefirst($_[1]),
3315							q{mult_op},
3316							$tracelevel)
3317							if defined $::RD_TRACE;
3318	2271					15882	return undef;
3319							}
3320	651	50	33			2981	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	651					1186	splice @{$thisparser->{errors}}, $err_at;
	651					1754
3329	651	50				2321	$return = $item[$#item] unless defined $return;
3330	651	50				1708	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	651					1484	$_[1] = $text;
3343	651					5353	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	4325			4325		8780	my $thisparser = $_[0];
3350	23			23		219	use vars q{$tracelevel};
	23					50
	23					170824
3351	4325		50			11303	local $tracelevel = ($tracelevel\|\|0)+1;
3352	4325					6557	$ERRORS = 0;
3353	4325					10280	my $thisrule = $thisparser->{"rules"}{"function_name"};
3354
3355	4325	50				10099	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	4325					6675	my $err_at = @{$thisparser->{errors}};
	4325					9802
3363
3364	4325					12074	my $score;
3365							my $score_return;
3366	4325					0	my $_tok;
3367	4325					6894	my $return = undef;
3368	4325					6216	my $_matched=0;
3369	4325					7534	my $commit=0;
3370	4325					7113	my @item = ();
3371	4325					7571	my %item = ();
3372	4325					6783	my $repeating = $_[2];
3373	4325					6705	my $_noactions = $_[3];
3374	4325	50				8566	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	4325					7158
	4325					8945
3375	4325					6984	my $_itempos = $_[5];
3376	4325	50				10451	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3377	4325					10247	my $text;
3378							my $lastsep;
3379	4325					0	my $current_match;
3380	4325					11782	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	4325					43982	$expectation->at($_[1]);
3382
3383	4325					18349	my $thisline;
3384	4325					14523	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3385
3386
3387
3388	4325		33			38628	while (!$_matched && !$commit)
3389							{
3390
3391	4325	50				9232	Parse::RecDescent::_trace(q{Trying production: ['log']},
3392							Parse::RecDescent::_tracefirst($_[1]),
3393							q{function_name},
3394							$tracelevel)
3395							if defined $::RD_TRACE;
3396	4325					10162	my $thisprod = $thisrule->{"prods"}[0];
3397	4325					7395	$text = $_[1];
3398	4325					6406	my $_savetext;
3399	4325					8984	@item = (q{function_name});
3400	4325					9580	%item = (__RULE__ => q{function_name});
3401	4325					6649	my $repcount = 0;
3402
3403
3404	4325	50				8811	Parse::RecDescent::_trace(q{Trying terminal: ['log']},
3405							Parse::RecDescent::_tracefirst($text),
3406							q{function_name},
3407							$tracelevel)
3408							if defined $::RD_TRACE;
3409	4325					7486	undef $lastsep;
3410	4325					10195	$expectation->is(q{})->at($text);
3411
3412
3413	4325	50	66			60297	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Alog/)
	4325	100				32874
3414							{
3415	4293	50				11511	$text = $lastsep . $text if defined $lastsep;
3416
3417	4293					13045	$expectation->failed();
3418	4293	50				17507	Parse::RecDescent::_trace(qq{<>},
3419							Parse::RecDescent::_tracefirst($text))
3420							if defined $::RD_TRACE;
3421	4293					9555	last;
3422							}
3423	32					200	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3424	32					110	substr($text,0,length($current_match),q{});
3425	32	50				97	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3426							. $current_match . q{])},
3427							Parse::RecDescent::_tracefirst($text))
3428							if defined $::RD_TRACE;
3429	32					120	push @item, $item{__STRING1__}=$current_match;
3430
3431
3432	32	50				100	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					63	$_matched = 1;
3441	32					87	last;
3442							}
3443
3444
3445	4325		66			16988	while (!$_matched && !$commit)
3446							{
3447
3448	4293	50				9295	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	4293					8547	my $thisprod = $thisrule->{"prods"}[1];
3454	4293					12012	$text = $_[1];
3455	4293					7517	my $_savetext;
3456	4293					9132	@item = (q{function_name});
3457	4293					10773	%item = (__RULE__ => q{function_name});
3458	4293					7011	my $repcount = 0;
3459
3460
3461	4293	50				8456	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	4293					7399	undef $lastsep;
3467	4293					11071	$expectation->is(q{})->at($text);
3468
3469
3470	4293	50	66			47707	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Apartial_derivative/)
	4293	100				27171
3471							{
3472	4049	50				9933	$text = $lastsep . $text if defined $lastsep;
3473
3474	4049					11299	$expectation->failed();
3475	4049	50				15144	Parse::RecDescent::_trace(qq{<>},
3476							Parse::RecDescent::_tracefirst($text))
3477							if defined $::RD_TRACE;
3478	4049					8249	last;
3479							}
3480	244					1386	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3481	244					836	substr($text,0,length($current_match),q{});
3482	244	50				685	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3483							. $current_match . q{])},
3484							Parse::RecDescent::_tracefirst($text))
3485							if defined $::RD_TRACE;
3486	244					880	push @item, $item{__STRING1__}=$current_match;
3487
3488
3489	244	50				674	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					408	$_matched = 1;
3498	244					522	last;
3499							}
3500
3501
3502	4325		66			23928	while (!$_matched && !$commit)
3503							{
3504
3505	4049	50				7726	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	4049					12090	my $thisprod = $thisrule->{"prods"}[2];
3511	4049					7575	$text = $_[1];
3512	4049					5921	my $_savetext;
3513	4049					8320	@item = (q{function_name});
3514	4049					9509	%item = (__RULE__ => q{function_name});
3515	4049					6337	my $repcount = 0;
3516
3517
3518	4049	50				9105	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	4049					6494	undef $lastsep;
3524	4049					9701	$expectation->is(q{})->at($text);
3525
3526
3527	4049	50	66			42026	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Atotal_derivative/)
	4049	100				27759
3528							{
3529	4023	50				9976	$text = $lastsep . $text if defined $lastsep;
3530
3531	4023					12929	$expectation->failed();
3532	4023	50				15330	Parse::RecDescent::_trace(qq{<>},
3533							Parse::RecDescent::_tracefirst($text))
3534							if defined $::RD_TRACE;
3535	4023					7862	last;
3536							}
3537	26					147	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3538	26					92	substr($text,0,length($current_match),q{});
3539	26	50				129	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3540							. $current_match . q{])},
3541							Parse::RecDescent::_tracefirst($text))
3542							if defined $::RD_TRACE;
3543	26					90	push @item, $item{__STRING1__}=$current_match;
3544
3545
3546	26	50				83	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					51	$_matched = 1;
3555	26					53	last;
3556							}
3557
3558
3559	4325		66			15346	while (!$_matched && !$commit)
3560							{
3561
3562	4023	50				8267	Parse::RecDescent::_trace(q{Trying production: ['sinh']},
3563							Parse::RecDescent::_tracefirst($_[1]),
3564							q{function_name},
3565							$tracelevel)
3566							if defined $::RD_TRACE;
3567	4023					7843	my $thisprod = $thisrule->{"prods"}[3];
3568	4023					6918	$text = $_[1];
3569	4023					6485	my $_savetext;
3570	4023					8164	@item = (q{function_name});
3571	4023					11079	%item = (__RULE__ => q{function_name});
3572	4023					6170	my $repcount = 0;
3573
3574
3575	4023	50				8031	Parse::RecDescent::_trace(q{Trying terminal: ['sinh']},
3576							Parse::RecDescent::_tracefirst($text),
3577							q{function_name},
3578							$tracelevel)
3579							if defined $::RD_TRACE;
3580	4023					6315	undef $lastsep;
3581	4023					8917	$expectation->is(q{})->at($text);
3582
3583
3584	4023	50	66			42570	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Asinh/)
	4023	100				25176
3585							{
3586	4013	50				10220	$text = $lastsep . $text if defined $lastsep;
3587
3588	4013					11366	$expectation->failed();
3589	4013	50				18404	Parse::RecDescent::_trace(qq{<>},
3590							Parse::RecDescent::_tracefirst($text))
3591							if defined $::RD_TRACE;
3592	4013					8665	last;
3593							}
3594	10					64	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3595	10					36	substr($text,0,length($current_match),q{});
3596	10	50				22	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3597							. $current_match . q{])},
3598							Parse::RecDescent::_tracefirst($text))
3599							if defined $::RD_TRACE;
3600	10					44	push @item, $item{__STRING1__}=$current_match;
3601
3602
3603	10	50				27	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					22	$_matched = 1;
3612	10					24	last;
3613							}
3614
3615
3616	4325		66			15601	while (!$_matched && !$commit)
3617							{
3618
3619	4013	50				8209	Parse::RecDescent::_trace(q{Trying production: ['cosh']},
3620							Parse::RecDescent::_tracefirst($_[1]),
3621							q{function_name},
3622							$tracelevel)
3623							if defined $::RD_TRACE;
3624	4013					7728	my $thisprod = $thisrule->{"prods"}[4];
3625	4013					6800	$text = $_[1];
3626	4013					6350	my $_savetext;
3627	4013					8229	@item = (q{function_name});
3628	4013					8928	%item = (__RULE__ => q{function_name});
3629	4013					6178	my $repcount = 0;
3630
3631
3632	4013	50				8044	Parse::RecDescent::_trace(q{Trying terminal: ['cosh']},
3633							Parse::RecDescent::_tracefirst($text),
3634							q{function_name},
3635							$tracelevel)
3636							if defined $::RD_TRACE;
3637	4013					6463	undef $lastsep;
3638	4013					10576	$expectation->is(q{})->at($text);
3639
3640
3641	4013	50	66			45334	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Acosh/)
	4013	100				24641
3642							{
3643	4003	50				10334	$text = $lastsep . $text if defined $lastsep;
3644
3645	4003					11170	$expectation->failed();
3646	4003	50				14531	Parse::RecDescent::_trace(qq{<>},
3647							Parse::RecDescent::_tracefirst($text))
3648							if defined $::RD_TRACE;
3649	4003					7386	last;
3650							}
3651	10					64	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3652	10					54	substr($text,0,length($current_match),q{});
3653	10	50				26	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3654							. $current_match . q{])},
3655							Parse::RecDescent::_tracefirst($text))
3656							if defined $::RD_TRACE;
3657	10					34	push @item, $item{__STRING1__}=$current_match;
3658
3659
3660	10	50				60	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					20	$_matched = 1;
3669	10					23	last;
3670							}
3671
3672
3673	4325		66			15050	while (!$_matched && !$commit)
3674							{
3675
3676	4003	50				7957	Parse::RecDescent::_trace(q{Trying production: ['asinh']},
3677							Parse::RecDescent::_tracefirst($_[1]),
3678							q{function_name},
3679							$tracelevel)
3680							if defined $::RD_TRACE;
3681	4003					7607	my $thisprod = $thisrule->{"prods"}[5];
3682	4003					7913	$text = $_[1];
3683	4003					6495	my $_savetext;
3684	4003					8163	@item = (q{function_name});
3685	4003					8965	%item = (__RULE__ => q{function_name});
3686	4003					6346	my $repcount = 0;
3687
3688
3689	4003	50				7966	Parse::RecDescent::_trace(q{Trying terminal: ['asinh']},
3690							Parse::RecDescent::_tracefirst($text),
3691							q{function_name},
3692							$tracelevel)
3693							if defined $::RD_TRACE;
3694	4003					6205	undef $lastsep;
3695	4003					9607	$expectation->is(q{})->at($text);
3696
3697
3698	4003	50	66			40976	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aasinh/)
	4003	100				26801
3699							{
3700	4001	50				9221	$text = $lastsep . $text if defined $lastsep;
3701
3702	4001					11610	$expectation->failed();
3703	4001	50				14647	Parse::RecDescent::_trace(qq{<>},
3704							Parse::RecDescent::_tracefirst($text))
3705							if defined $::RD_TRACE;
3706	4001					7686	last;
3707							}
3708	2					17	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3709	2					9	substr($text,0,length($current_match),q{});
3710	2	50				11	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3711							. $current_match . q{])},
3712							Parse::RecDescent::_tracefirst($text))
3713							if defined $::RD_TRACE;
3714	2					11	push @item, $item{__STRING1__}=$current_match;
3715
3716
3717	2	50				7	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					6	last;
3727							}
3728
3729
3730	4325		66			14856	while (!$_matched && !$commit)
3731							{
3732
3733	4001	50				8430	Parse::RecDescent::_trace(q{Trying production: ['acosh']},
3734							Parse::RecDescent::_tracefirst($_[1]),
3735							q{function_name},
3736							$tracelevel)
3737							if defined $::RD_TRACE;
3738	4001					7631	my $thisprod = $thisrule->{"prods"}[6];
3739	4001					7152	$text = $_[1];
3740	4001					6047	my $_savetext;
3741	4001					8377	@item = (q{function_name});
3742	4001					8770	%item = (__RULE__ => q{function_name});
3743	4001					7217	my $repcount = 0;
3744
3745
3746	4001	50				8154	Parse::RecDescent::_trace(q{Trying terminal: ['acosh']},
3747							Parse::RecDescent::_tracefirst($text),
3748							q{function_name},
3749							$tracelevel)
3750							if defined $::RD_TRACE;
3751	4001					6300	undef $lastsep;
3752	4001					10240	$expectation->is(q{})->at($text);
3753
3754
3755	4001	50	66			40615	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aacosh/)
	4001	100				24399
3756							{
3757	3999	50				9441	$text = $lastsep . $text if defined $lastsep;
3758
3759	3999					11313	$expectation->failed();
3760	3999	50				14793	Parse::RecDescent::_trace(qq{<>},
3761							Parse::RecDescent::_tracefirst($text))
3762							if defined $::RD_TRACE;
3763	3999					7434	last;
3764							}
3765	2					16	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3766	2					8	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					10	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					5	last;
3784							}
3785
3786
3787	4325		66			15515	while (!$_matched && !$commit)
3788							{
3789
3790	3999	50				9970	Parse::RecDescent::_trace(q{Trying production: ['asin']},
3791							Parse::RecDescent::_tracefirst($_[1]),
3792							q{function_name},
3793							$tracelevel)
3794							if defined $::RD_TRACE;
3795	3999					7671	my $thisprod = $thisrule->{"prods"}[7];
3796	3999					6789	$text = $_[1];
3797	3999					6557	my $_savetext;
3798	3999					7814	@item = (q{function_name});
3799	3999					9861	%item = (__RULE__ => q{function_name});
3800	3999					6186	my $repcount = 0;
3801
3802
3803	3999	50				8693	Parse::RecDescent::_trace(q{Trying terminal: ['asin']},
3804							Parse::RecDescent::_tracefirst($text),
3805							q{function_name},
3806							$tracelevel)
3807							if defined $::RD_TRACE;
3808	3999					6489	undef $lastsep;
3809	3999					9435	$expectation->is(q{})->at($text);
3810
3811
3812	3999	50	66			40971	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aasin/)
	3999	100				25371
3813							{
3814	3997	50				13101	$text = $lastsep . $text if defined $lastsep;
3815
3816	3997					10672	$expectation->failed();
3817	3997	50				15712	Parse::RecDescent::_trace(qq{<>},
3818							Parse::RecDescent::_tracefirst($text))
3819							if defined $::RD_TRACE;
3820	3997					7574	last;
3821							}
3822	2					15	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3823	2					9	substr($text,0,length($current_match),q{});
3824	2	50				9	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3825							. $current_match . q{])},
3826							Parse::RecDescent::_tracefirst($text))
3827							if defined $::RD_TRACE;
3828	2					12	push @item, $item{__STRING1__}=$current_match;
3829
3830
3831	2	50				23	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					4061	$_matched = 1;
3840	2					12	last;
3841							}
3842
3843
3844	4325		66			15159	while (!$_matched && !$commit)
3845							{
3846
3847	3997	50				9424	Parse::RecDescent::_trace(q{Trying production: ['acos']},
3848							Parse::RecDescent::_tracefirst($_[1]),
3849							q{function_name},
3850							$tracelevel)
3851							if defined $::RD_TRACE;
3852	3997					7808	my $thisprod = $thisrule->{"prods"}[8];
3853	3997					7269	$text = $_[1];
3854	3997					5780	my $_savetext;
3855	3997					25060	@item = (q{function_name});
3856	3997					8466	%item = (__RULE__ => q{function_name});
3857	3997					6220	my $repcount = 0;
3858
3859
3860	3997	50				7845	Parse::RecDescent::_trace(q{Trying terminal: ['acos']},
3861							Parse::RecDescent::_tracefirst($text),
3862							q{function_name},
3863							$tracelevel)
3864							if defined $::RD_TRACE;
3865	3997					10193	undef $lastsep;
3866	3997					9043	$expectation->is(q{})->at($text);
3867
3868
3869	3997	50	66			42561	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aacos/)
	3997	100				24799
3870							{
3871	3993	50				9382	$text = $lastsep . $text if defined $lastsep;
3872
3873	3993					10489	$expectation->failed();
3874	3993	50				14815	Parse::RecDescent::_trace(qq{<>},
3875							Parse::RecDescent::_tracefirst($text))
3876							if defined $::RD_TRACE;
3877	3993					7701	last;
3878							}
3879	4					31	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3880	4					20	substr($text,0,length($current_match),q{});
3881	4	50				18	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3882							. $current_match . q{])},
3883							Parse::RecDescent::_tracefirst($text))
3884							if defined $::RD_TRACE;
3885	4					17	push @item, $item{__STRING1__}=$current_match;
3886
3887
3888	4	50				15	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					9	$_matched = 1;
3897	4					12	last;
3898							}
3899
3900
3901	4325		66			14378	while (!$_matched && !$commit)
3902							{
3903
3904	3993	50				9045	Parse::RecDescent::_trace(q{Trying production: ['atan2']},
3905							Parse::RecDescent::_tracefirst($_[1]),
3906							q{function_name},
3907							$tracelevel)
3908							if defined $::RD_TRACE;
3909	3993					7380	my $thisprod = $thisrule->{"prods"}[9];
3910	3993					6931	$text = $_[1];
3911	3993					5894	my $_savetext;
3912	3993					7871	@item = (q{function_name});
3913	3993					8863	%item = (__RULE__ => q{function_name});
3914	3993					6449	my $repcount = 0;
3915
3916
3917	3993	50				8562	Parse::RecDescent::_trace(q{Trying terminal: ['atan2']},
3918							Parse::RecDescent::_tracefirst($text),
3919							q{function_name},
3920							$tracelevel)
3921							if defined $::RD_TRACE;
3922	3993					6653	undef $lastsep;
3923	3993					9353	$expectation->is(q{})->at($text);
3924
3925
3926	3993	50	33			40779	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aatan2/)
	3993	50				24007
3927							{
3928	3993	50				10636	$text = $lastsep . $text if defined $lastsep;
3929
3930	3993					10880	$expectation->failed();
3931	3993	50				14417	Parse::RecDescent::_trace(qq{<>},
3932							Parse::RecDescent::_tracefirst($text))
3933							if defined $::RD_TRACE;
3934	3993					7429	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	4325		66			15110	while (!$_matched && !$commit)
3959							{
3960
3961	3993	50				9942	Parse::RecDescent::_trace(q{Trying production: ['atan']},
3962							Parse::RecDescent::_tracefirst($_[1]),
3963							q{function_name},
3964							$tracelevel)
3965							if defined $::RD_TRACE;
3966	3993					7826	my $thisprod = $thisrule->{"prods"}[10];
3967	3993					6628	$text = $_[1];
3968	3993					6602	my $_savetext;
3969	3993					8013	@item = (q{function_name});
3970	3993					9449	%item = (__RULE__ => q{function_name});
3971	3993					5947	my $repcount = 0;
3972
3973
3974	3993	50				8076	Parse::RecDescent::_trace(q{Trying terminal: ['atan']},
3975							Parse::RecDescent::_tracefirst($text),
3976							q{function_name},
3977							$tracelevel)
3978							if defined $::RD_TRACE;
3979	3993					7711	undef $lastsep;
3980	3993					8928	$expectation->is(q{})->at($text);
3981
3982
3983	3993	50	66			40665	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aatan/)
	3993	100				23991
3984							{
3985	3991	50				9290	$text = $lastsep . $text if defined $lastsep;
3986
3987	3991					10724	$expectation->failed();
3988	3991	50				14417	Parse::RecDescent::_trace(qq{<>},
3989							Parse::RecDescent::_tracefirst($text))
3990							if defined $::RD_TRACE;
3991	3991					7517	last;
3992							}
3993	2					14	$current_match = substr($text, $-[0], $+[0] - $-[0]);
3994	2					9	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					8	push @item, $item{__STRING1__}=$current_match;
4000
4001
4002	2	50				7	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					5	$_matched = 1;
4011	2					4	last;
4012							}
4013
4014
4015	4325		66			14826	while (!$_matched && !$commit)
4016							{
4017
4018	3991	50				8656	Parse::RecDescent::_trace(q{Trying production: ['acot']},
4019							Parse::RecDescent::_tracefirst($_[1]),
4020							q{function_name},
4021							$tracelevel)
4022							if defined $::RD_TRACE;
4023	3991					7472	my $thisprod = $thisrule->{"prods"}[11];
4024	3991					6570	$text = $_[1];
4025	3991					5742	my $_savetext;
4026	3991					8280	@item = (q{function_name});
4027	3991					9250	%item = (__RULE__ => q{function_name});
4028	3991					5972	my $repcount = 0;
4029
4030
4031	3991	50				7983	Parse::RecDescent::_trace(q{Trying terminal: ['acot']},
4032							Parse::RecDescent::_tracefirst($text),
4033							q{function_name},
4034							$tracelevel)
4035							if defined $::RD_TRACE;
4036	3991					6135	undef $lastsep;
4037	3991					9150	$expectation->is(q{})->at($text);
4038
4039
4040	3991	50	66			44643	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aacot/)
	3991	100				24462
4041							{
4042	3989	50				10049	$text = $lastsep . $text if defined $lastsep;
4043
4044	3989					10940	$expectation->failed();
4045	3989	50				14529	Parse::RecDescent::_trace(qq{<>},
4046							Parse::RecDescent::_tracefirst($text))
4047							if defined $::RD_TRACE;
4048	3989					7364	last;
4049							}
4050	2					16	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4051	2					7	substr($text,0,length($current_match),q{});
4052	2	50				9	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4053							. $current_match . q{])},
4054							Parse::RecDescent::_tracefirst($text))
4055							if defined $::RD_TRACE;
4056	2					9	push @item, $item{__STRING1__}=$current_match;
4057
4058
4059	2	50				7	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					5	last;
4069							}
4070
4071
4072	4325		66			13969	while (!$_matched && !$commit)
4073							{
4074
4075	3989	50				8509	Parse::RecDescent::_trace(q{Trying production: ['sin']},
4076							Parse::RecDescent::_tracefirst($_[1]),
4077							q{function_name},
4078							$tracelevel)
4079							if defined $::RD_TRACE;
4080	3989					8061	my $thisprod = $thisrule->{"prods"}[12];
4081	3989					6488	$text = $_[1];
4082	3989					5945	my $_savetext;
4083	3989					7973	@item = (q{function_name});
4084	3989					8816	%item = (__RULE__ => q{function_name});
4085	3989					6159	my $repcount = 0;
4086
4087
4088	3989	50				7939	Parse::RecDescent::_trace(q{Trying terminal: ['sin']},
4089							Parse::RecDescent::_tracefirst($text),
4090							q{function_name},
4091							$tracelevel)
4092							if defined $::RD_TRACE;
4093	3989					6152	undef $lastsep;
4094	3989					8825	$expectation->is(q{})->at($text);
4095
4096
4097	3989	50	66			41316	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Asin/)
	3989	100				23724
4098							{
4099	3895	50				9932	$text = $lastsep . $text if defined $lastsep;
4100
4101	3895					10888	$expectation->failed();
4102	3895	50				15454	Parse::RecDescent::_trace(qq{<>},
4103							Parse::RecDescent::_tracefirst($text))
4104							if defined $::RD_TRACE;
4105	3895					7286	last;
4106							}
4107	94					563	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4108	94					294	substr($text,0,length($current_match),q{});
4109	94	50				265	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4110							. $current_match . q{])},
4111							Parse::RecDescent::_tracefirst($text))
4112							if defined $::RD_TRACE;
4113	94					327	push @item, $item{__STRING1__}=$current_match;
4114
4115
4116	94	50				235	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					150	$_matched = 1;
4125	94					269	last;
4126							}
4127
4128
4129	4325		66			14629	while (!$_matched && !$commit)
4130							{
4131
4132	3895	50				7544	Parse::RecDescent::_trace(q{Trying production: ['cos']},
4133							Parse::RecDescent::_tracefirst($_[1]),
4134							q{function_name},
4135							$tracelevel)
4136							if defined $::RD_TRACE;
4137	3895					7475	my $thisprod = $thisrule->{"prods"}[13];
4138	3895					6437	$text = $_[1];
4139	3895					7909	my $_savetext;
4140	3895					8865	@item = (q{function_name});
4141	3895					9019	%item = (__RULE__ => q{function_name});
4142	3895					6060	my $repcount = 0;
4143
4144
4145	3895	50				11483	Parse::RecDescent::_trace(q{Trying terminal: ['cos']},
4146							Parse::RecDescent::_tracefirst($text),
4147							q{function_name},
4148							$tracelevel)
4149							if defined $::RD_TRACE;
4150	3895					6350	undef $lastsep;
4151	3895					8835	$expectation->is(q{})->at($text);
4152
4153
4154	3895	50	66			39540	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Acos/)
	3895	100				24754
4155							{
4156	3857	50				9180	$text = $lastsep . $text if defined $lastsep;
4157
4158	3857					10362	$expectation->failed();
4159	3857	50				13982	Parse::RecDescent::_trace(qq{<>},
4160							Parse::RecDescent::_tracefirst($text))
4161							if defined $::RD_TRACE;
4162	3857					8656	last;
4163							}
4164	38					242	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4165	38					129	substr($text,0,length($current_match),q{});
4166	38	50				118	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4167							. $current_match . q{])},
4168							Parse::RecDescent::_tracefirst($text))
4169							if defined $::RD_TRACE;
4170	38					124	push @item, $item{__STRING1__}=$current_match;
4171
4172
4173	38	50				110	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					71	$_matched = 1;
4182	38					75	last;
4183							}
4184
4185
4186	4325		66			14327	while (!$_matched && !$commit)
4187							{
4188
4189	3857	50				7770	Parse::RecDescent::_trace(q{Trying production: ['tan']},
4190							Parse::RecDescent::_tracefirst($_[1]),
4191							q{function_name},
4192							$tracelevel)
4193							if defined $::RD_TRACE;
4194	3857					8009	my $thisprod = $thisrule->{"prods"}[14];
4195	3857					6698	$text = $_[1];
4196	3857					5916	my $_savetext;
4197	3857					9712	@item = (q{function_name});
4198	3857					8348	%item = (__RULE__ => q{function_name});
4199	3857					5835	my $repcount = 0;
4200
4201
4202	3857	50				9487	Parse::RecDescent::_trace(q{Trying terminal: ['tan']},
4203							Parse::RecDescent::_tracefirst($text),
4204							q{function_name},
4205							$tracelevel)
4206							if defined $::RD_TRACE;
4207	3857					8986	undef $lastsep;
4208	3857					8908	$expectation->is(q{})->at($text);
4209
4210
4211	3857	50	66			39839	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Atan/)
	3857	100				36734
4212							{
4213	3845	50				9824	$text = $lastsep . $text if defined $lastsep;
4214
4215	3845					11044	$expectation->failed();
4216	3845	50				14679	Parse::RecDescent::_trace(qq{<>},
4217							Parse::RecDescent::_tracefirst($text))
4218							if defined $::RD_TRACE;
4219	3845					7592	last;
4220							}
4221	12					88	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4222	12					46	substr($text,0,length($current_match),q{});
4223	12	50				56	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4224							. $current_match . q{])},
4225							Parse::RecDescent::_tracefirst($text))
4226							if defined $::RD_TRACE;
4227	12					43	push @item, $item{__STRING1__}=$current_match;
4228
4229
4230	12	50				48	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					31	$_matched = 1;
4239	12					30	last;
4240							}
4241
4242
4243	4325		66			14035	while (!$_matched && !$commit)
4244							{
4245
4246	3845	50				7768	Parse::RecDescent::_trace(q{Trying production: ['cot']},
4247							Parse::RecDescent::_tracefirst($_[1]),
4248							q{function_name},
4249							$tracelevel)
4250							if defined $::RD_TRACE;
4251	3845					7661	my $thisprod = $thisrule->{"prods"}[15];
4252	3845					7168	$text = $_[1];
4253	3845					6375	my $_savetext;
4254	3845					8736	@item = (q{function_name});
4255	3845					8678	%item = (__RULE__ => q{function_name});
4256	3845					5669	my $repcount = 0;
4257
4258
4259	3845	50				9761	Parse::RecDescent::_trace(q{Trying terminal: ['cot']},
4260							Parse::RecDescent::_tracefirst($text),
4261							q{function_name},
4262							$tracelevel)
4263							if defined $::RD_TRACE;
4264	3845					6599	undef $lastsep;
4265	3845					8914	$expectation->is(q{})->at($text);
4266
4267
4268	3845	50	66			38583	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Acot/)
	3845	100				23539
4269							{
4270	3843	50				8888	$text = $lastsep . $text if defined $lastsep;
4271
4272	3843					10377	$expectation->failed();
4273	3843	50				14113	Parse::RecDescent::_trace(qq{<>},
4274							Parse::RecDescent::_tracefirst($text))
4275							if defined $::RD_TRACE;
4276	3843					7354	last;
4277							}
4278	2					14	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4279	2					9	substr($text,0,length($current_match),q{});
4280	2	50				7	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4281							. $current_match . q{])},
4282							Parse::RecDescent::_tracefirst($text))
4283							if defined $::RD_TRACE;
4284	2					8	push @item, $item{__STRING1__}=$current_match;
4285
4286
4287	2	50				25	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					5	$_matched = 1;
4296	2					22	last;
4297							}
4298
4299
4300	4325		66			14254	while (!$_matched && !$commit)
4301							{
4302
4303	3843	50				11519	Parse::RecDescent::_trace(q{Trying production: ['exp']},
4304							Parse::RecDescent::_tracefirst($_[1]),
4305							q{function_name},
4306							$tracelevel)
4307							if defined $::RD_TRACE;
4308	3843					8938	my $thisprod = $thisrule->{"prods"}[16];
4309	3843					6501	$text = $_[1];
4310	3843					6535	my $_savetext;
4311	3843					7735	@item = (q{function_name});
4312	3843					8668	%item = (__RULE__ => q{function_name});
4313	3843					6317	my $repcount = 0;
4314
4315
4316	3843	50				10846	Parse::RecDescent::_trace(q{Trying terminal: ['exp']},
4317							Parse::RecDescent::_tracefirst($text),
4318							q{function_name},
4319							$tracelevel)
4320							if defined $::RD_TRACE;
4321	3843					6094	undef $lastsep;
4322	3843					9125	$expectation->is(q{})->at($text);
4323
4324
4325	3843	50	66			38747	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Aexp/)
	3843	100				22792
4326							{
4327	3837	50				8913	$text = $lastsep . $text if defined $lastsep;
4328
4329	3837					10772	$expectation->failed();
4330	3837	50				14575	Parse::RecDescent::_trace(qq{<>},
4331							Parse::RecDescent::_tracefirst($text))
4332							if defined $::RD_TRACE;
4333	3837					7555	last;
4334							}
4335	6					46	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4336	6					23	substr($text,0,length($current_match),q{});
4337	6	50				44	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4338							. $current_match . q{])},
4339							Parse::RecDescent::_tracefirst($text))
4340							if defined $::RD_TRACE;
4341	6					24	push @item, $item{__STRING1__}=$current_match;
4342
4343
4344	6	50				23	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					14	$_matched = 1;
4353	6					13	last;
4354							}
4355
4356
4357	4325		66			16847	while (!$_matched && !$commit)
4358							{
4359
4360	3837	50				7367	Parse::RecDescent::_trace(q{Trying production: ['sqrt']},
4361							Parse::RecDescent::_tracefirst($_[1]),
4362							q{function_name},
4363							$tracelevel)
4364							if defined $::RD_TRACE;
4365	3837					7563	my $thisprod = $thisrule->{"prods"}[17];
4366	3837					6407	$text = $_[1];
4367	3837					5402	my $_savetext;
4368	3837					7841	@item = (q{function_name});
4369	3837					9045	%item = (__RULE__ => q{function_name});
4370	3837					6397	my $repcount = 0;
4371
4372
4373	3837	50				7945	Parse::RecDescent::_trace(q{Trying terminal: ['sqrt']},
4374							Parse::RecDescent::_tracefirst($text),
4375							q{function_name},
4376							$tracelevel)
4377							if defined $::RD_TRACE;
4378	3837					6385	undef $lastsep;
4379	3837					8926	$expectation->is(q{})->at($text);
4380
4381
4382	3837	50	66			39612	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\Asqrt/)
	3837	100				22454
4383							{
4384	3835	50				8711	$text = $lastsep . $text if defined $lastsep;
4385
4386	3835					10609	$expectation->failed();
4387	3835	50				13822	Parse::RecDescent::_trace(qq{<>},
4388							Parse::RecDescent::_tracefirst($text))
4389							if defined $::RD_TRACE;
4390	3835					7024	last;
4391							}
4392	2					16	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4393	2					9	substr($text,0,length($current_match),q{});
4394	2	50				9	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4395							. $current_match . q{])},
4396							Parse::RecDescent::_tracefirst($text))
4397							if defined $::RD_TRACE;
4398	2					7	push @item, $item{__STRING1__}=$current_match;
4399
4400
4401	2	50				7	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					5	$_matched = 1;
4410	2					5	last;
4411							}
4412
4413
4414	4325	100	66			14159	unless ( $_matched \|\| defined($score) )
4415							{
4416
4417
4418	3835					7859	$_[1] = $text; # NOT SURE THIS IS NEEDED
4419	3835	50				7731	Parse::RecDescent::_trace(q{<>},
4420							Parse::RecDescent::_tracefirst($_[1]),
4421							q{function_name},
4422							$tracelevel)
4423							if defined $::RD_TRACE;
4424	3835					35803	return undef;
4425							}
4426	490	50	33			2307	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					924	splice @{$thisparser->{errors}}, $err_at;
	490					1632
4435	490	50				1857	$return = $item[$#item] unless defined $return;
4436	490	50				1401	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					1159	$_[1] = $text;
4449	490					4631	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	2271			2271		4132	my $thisparser = $_[0];
4456	23			23		255	use vars q{$tracelevel};
	23					58
	23					28747
4457	2271		50			6406	local $tracelevel = ($tracelevel\|\|0)+1;
4458	2271					3760	$ERRORS = 0;
4459	2271					5884	my $thisrule = $thisparser->{"rules"}{"add_op"};
4460
4461	2271	50				5354	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	2271					4428	my $err_at = @{$thisparser->{errors}};
	2271					5357
4469
4470	2271					10959	my $score;
4471							my $score_return;
4472	2271					0	my $_tok;
4473	2271					3877	my $return = undef;
4474	2271					4042	my $_matched=0;
4475	2271					3790	my $commit=0;
4476	2271					4165	my @item = ();
4477	2271					4027	my %item = ();
4478	2271					3801	my $repeating = $_[2];
4479	2271					3843	my $_noactions = $_[3];
4480	2271	50				5749	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	2271					3467
	2271					4584
4481	2271					3749	my $_itempos = $_[5];
4482	2271	50				6721	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4483	2271					6563	my $text;
4484							my $lastsep;
4485	2271					0	my $current_match;
4486	2271					8039	my $expectation = new Parse::RecDescent::Expectation(q{'+', or '-'});
4487	2271					21218	$expectation->at($_[1]);
4488
4489	2271					10041	my $thisline;
4490	2271					9922	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4491
4492
4493
4494	2271		33			22267	while (!$_matched && !$commit)
4495							{
4496
4497	2271	50				5626	Parse::RecDescent::_trace(q{Trying production: ['+']},
4498							Parse::RecDescent::_tracefirst($_[1]),
4499							q{add_op},
4500							$tracelevel)
4501							if defined $::RD_TRACE;
4502	2271					5655	my $thisprod = $thisrule->{"prods"}[0];
4503	2271					4091	$text = $_[1];
4504	2271					3494	my $_savetext;
4505	2271					14735	@item = (q{add_op});
4506	2271					5528	%item = (__RULE__ => q{add_op});
4507	2271					7713	my $repcount = 0;
4508
4509
4510	2271	50				5169	Parse::RecDescent::_trace(q{Trying terminal: ['+']},
4511							Parse::RecDescent::_tracefirst($text),
4512							q{add_op},
4513							$tracelevel)
4514							if defined $::RD_TRACE;
4515	2271					4436	undef $lastsep;
4516	2271					6177	$expectation->is(q{})->at($text);
4517
4518
4519	2271	50	66			31982	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\+/)
	2271	100				18471
4520							{
4521	1896	50				5782	$text = $lastsep . $text if defined $lastsep;
4522
4523	1896					6434	$expectation->failed();
4524	1896	50				8139	Parse::RecDescent::_trace(qq{<>},
4525							Parse::RecDescent::_tracefirst($text))
4526							if defined $::RD_TRACE;
4527	1896					9375	last;
4528							}
4529	375					2278	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4530	375					1365	substr($text,0,length($current_match),q{});
4531	375	50				1087	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4532							. $current_match . q{])},
4533							Parse::RecDescent::_tracefirst($text))
4534							if defined $::RD_TRACE;
4535	375					1347	push @item, $item{__STRING1__}=$current_match;
4536
4537
4538	375	50				928	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	375					653	$_matched = 1;
4547	375					818	last;
4548							}
4549
4550
4551	2271		66			10466	while (!$_matched && !$commit)
4552							{
4553
4554	1896	50				4516	Parse::RecDescent::_trace(q{Trying production: ['-']},
4555							Parse::RecDescent::_tracefirst($_[1]),
4556							q{add_op},
4557							$tracelevel)
4558							if defined $::RD_TRACE;
4559	1896					4184	my $thisprod = $thisrule->{"prods"}[1];
4560	1896					3524	$text = $_[1];
4561	1896					3046	my $_savetext;
4562	1896					4691	@item = (q{add_op});
4563	1896					5268	%item = (__RULE__ => q{add_op});
4564	1896					3233	my $repcount = 0;
4565
4566
4567	1896	50				4521	Parse::RecDescent::_trace(q{Trying terminal: ['-']},
4568							Parse::RecDescent::_tracefirst($text),
4569							q{add_op},
4570							$tracelevel)
4571							if defined $::RD_TRACE;
4572	1896					4536	undef $lastsep;
4573	1896					6493	$expectation->is(q{})->at($text);
4574
4575
4576	1896	50	66			23012	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\-/)
	1896	100				12859
4577							{
4578	1779	50				4720	$text = $lastsep . $text if defined $lastsep;
4579
4580	1779					5295	$expectation->failed();
4581	1779	50				7111	Parse::RecDescent::_trace(qq{<>},
4582							Parse::RecDescent::_tracefirst($text))
4583							if defined $::RD_TRACE;
4584	1779					3496	last;
4585							}
4586	117					746	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4587	117					407	substr($text,0,length($current_match),q{});
4588	117	50				407	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4589							. $current_match . q{])},
4590							Parse::RecDescent::_tracefirst($text))
4591							if defined $::RD_TRACE;
4592	117					431	push @item, $item{__STRING1__}=$current_match;
4593
4594
4595	117	50				375	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					226	$_matched = 1;
4604	117					243	last;
4605							}
4606
4607
4608	2271	100	66			8029	unless ( $_matched \|\| defined($score) )
4609							{
4610
4611
4612	1779					3505	$_[1] = $text; # NOT SURE THIS IS NEEDED
4613	1779	50				4073	Parse::RecDescent::_trace(q{<>},
4614							Parse::RecDescent::_tracefirst($_[1]),
4615							q{add_op},
4616							$tracelevel)
4617							if defined $::RD_TRACE;
4618	1779					16835	return undef;
4619							}
4620	492	50	33			2284	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	492					1040	splice @{$thisparser->{errors}}, $err_at;
	492					1459
4629	492	50				1728	$return = $item[$#item] unless defined $return;
4630	492	50				1292	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	492					2551	$_[1] = $text;
4643	492					4305	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		1290	my $thisparser = $_[0];
4650	23			23		196	use vars q{$tracelevel};
	23					94
	23					10269
4651	490		50			1658	local $tracelevel = ($tracelevel\|\|0)+1;
4652	490					897	$ERRORS = 0;
4653	490					1370	my $thisrule = $thisparser->{"rules"}{"expr_list"};
4654
4655	490	50				1209	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					837	my $err_at = @{$thisparser->{errors}};
	490					1251
4663
4664	490					1521	my $score;
4665							my $score_return;
4666	490					0	my $_tok;
4667	490					869	my $return = undef;
4668	490					1014	my $_matched=0;
4669	490					826	my $commit=0;
4670	490					1058	my @item = ();
4671	490					940	my %item = ();
4672	490					875	my $repeating = $_[2];
4673	490					910	my $_noactions = $_[3];
4674	490	50				1324	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	490					824
	490					1130
4675	490					917	my $_itempos = $_[5];
4676	490	50				1546	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4677	490					1496	my $text;
4678							my $lastsep;
4679	490					0	my $current_match;
4680	490					1719	my $expectation = new Parse::RecDescent::Expectation(q{});
4681	490					4714	$expectation->at($_[1]);
4682
4683	490					2244	my $thisline;
4684	490					2303	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4685
4686
4687
4688	490		33			4646	while (!$_matched && !$commit)
4689							{
4690
4691	490	50				1264	Parse::RecDescent::_trace(q{Trying production: []},
4692							Parse::RecDescent::_tracefirst($_[1]),
4693							q{expr_list},
4694							$tracelevel)
4695							if defined $::RD_TRACE;
4696	490					1533	my $thisprod = $thisrule->{"prods"}[0];
4697	490					1109	$text = $_[1];
4698	490					884	my $_savetext;
4699	490					1132	@item = (q{expr_list});
4700	490					1249	%item = (__RULE__ => q{expr_list});
4701	490					958	my $repcount = 0;
4702
4703
4704	490	50				1164	Parse::RecDescent::_trace(q{Trying operator: []},
4705							Parse::RecDescent::_tracefirst($text),
4706							q{expr_list},
4707							$tracelevel)
4708							if defined $::RD_TRACE;
4709	490					1407	$expectation->is(q{})->at($text);
4710
4711	490					4153	$_tok = undef;
4712	490					1012	OPLOOP: while (1)
4713							{
4714	490					877	$repcount = 0;
4715	490					1009	my @item;
4716							my %item;
4717
4718							# MATCH LEFTARG
4719
4720	490	50				1268	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		199	if (1) { no strict qw{refs};
	23					73
	23					10632
	490					784
4726	490					1191	$expectation->is(q{expr})->at($text);
4727	490	50		490		5547	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	490					1074
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				2317	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					1435	$item{q{expr}} = $_tok;
4746	490					1049	push @item, $_tok;
4747
4748							}
4749
4750
4751
4752	490					872	$repcount++;
4753
4754	490					959	my $savetext = $text;
4755	490					983	my $backtrack;
4756
4757							# MATCH (OP RIGHTARG)(s)
4758	490					1539	while ($repcount < 100000000)
4759							{
4760	792					1438	$backtrack = 0;
4761
4762	792	50				1974	Parse::RecDescent::_trace(q{Trying terminal: [',']},
4763							Parse::RecDescent::_tracefirst($text),
4764							q{expr_list},
4765							$tracelevel)
4766							if defined $::RD_TRACE;
4767	792					1467	undef $lastsep;
4768	792					2749	$expectation->is(q{','})->at($text);
4769
4770
4771	792	50	66			12208	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\,/)
	792	100				10319
4772							{
4773	490	50				1654	$text = $lastsep . $text if defined $lastsep;
4774
4775	490					1893	$expectation->failed();
4776	490	50				4627	Parse::RecDescent::_trace(qq{<>},
4777							Parse::RecDescent::_tracefirst($text))
4778							if defined $::RD_TRACE;
4779	490					992	last;
4780							}
4781	302					1785	$current_match = substr($text, $-[0], $+[0] - $-[0]);
4782	302					1000	substr($text,0,length($current_match),q{});
4783	302	50				784	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4784							. $current_match . q{])},
4785							Parse::RecDescent::_tracefirst($text))
4786							if defined $::RD_TRACE;
4787	302					1054	push @item, $item{__STRING1__}=$current_match;
4788
4789
4790	302					631	pop @item;
4791
4792
4793	302	50				912	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		242	if (1) { no strict qw{refs};
	23					83
	23					102372
	302					557
4799	302					873	$expectation->is(q{expr})->at($text);
4800	302	50		302		5046	unless (defined ($_tok = Parse::RecDescent::Math::Symbolic::Parser::Precompiled::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg },undef)))
	302					667
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				1238	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					854	$item{q{expr}} = $_tok;
4819	302					601	push @item, $_tok;
4820
4821							}
4822
4823	302					657	$savetext = $text;
4824	302					938	$repcount++;
4825							}
4826	490					1164	$text = $savetext;
4827	490	50				1230	pop @item if $backtrack;
4828
4829	490	50				1306	unless (@item) { undef $_tok; last }
	0					0
	0					0
4830	490					1357	$_tok = [ @item ];
4831
4832	490					1487	last;
4833							} # end of OPLOOP
4834
4835	490	50				1507	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				1355	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			1939	push @item, $item{__DIRECTIVE1__}=$_tok\|\|[];
4853
4854	490	50				1248	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				1222	$_tok = ($_noactions) ? 0 : do {
4862							#warn 'expr_list '
4863							# if $Math::Symbolic::Parser::DEBUG;
4864	490					2523	$item[1]
4865							};
4866	490	50				1277	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				1185	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4873							. $_tok . q{])},
4874							Parse::RecDescent::_tracefirst($text))
4875							if defined $::RD_TRACE;
4876	490					932	push @item, $_tok;
4877	490					1169	$item{__ACTION1__}=$_tok;
4878
4879
4880	490	50				1246	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					979	$_matched = 1;
4889	490					1003	last;
4890							}
4891
4892
4893	490	50	33			1529	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			2291	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					916	splice @{$thisparser->{errors}}, $err_at;
	490					1278
4914	490	50				1702	$return = $item[$#item] unless defined $return;
4915	490	50				1370	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					1392	$_[1] = $text;
4928	490					4448	return $return;
4929							}
4930							}
4931	24			24	0	10128	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;